diff --git a/crates/cache/src/lib.rs b/crates/cache/src/lib.rs
index 58a13d354..9a9662661 100644
--- a/crates/cache/src/lib.rs
+++ b/crates/cache/src/lib.rs
@@ -44,7 +44,11 @@ pub trait CacheIssuer: Send + Sync + 'static {
     /// The key is used to identify the rate limit.
     type Key: Hash + Eq + Send + Sync + 'static;
     /// Issue a new key for the request. If it returns `None`, the request will not be cached.
-    fn issue(&self, req: &mut Request, depot: &Depot) -> impl Future<Output = Option<Self::Key>> + Send;
+    fn issue(
+        &self,
+        req: &mut Request,
+        depot: &Depot,
+    ) -> impl Future<Output = Option<Self::Key>> + Send;
 }
 impl<F, K> CacheIssuer for F
 where
@@ -153,7 +157,11 @@ pub trait CacheStore: Send + Sync + 'static {
         Self::Key: Borrow<Q>,
         Q: Hash + Eq + Sync;
     /// Save the cache item from the store.
-    fn save_entry(&self, key: Self::Key, data: CachedEntry) -> impl Future<Output = Result<(), Self::Error>> + Send;
+    fn save_entry(
+        &self,
+        key: Self::Key,
+        data: CachedEntry,
+    ) -> impl Future<Output = Result<(), Self::Error>> + Send;
 }
 
 /// `CachedBody` is used to save response body to `CachedStore`.
@@ -207,7 +215,11 @@ pub struct CachedEntry {
 impl CachedEntry {
     /// Create a new `CachedEntry`.
     pub fn new(status: Option<StatusCode>, headers: HeaderMap, body: CachedBody) -> Self {
-        Self { status, headers, body }
+        Self {
+            status,
+            headers,
+            body,
+        }
     }
 
     /// Get the response status.
@@ -279,7 +291,13 @@ where
     S: CacheStore<Key = I::Key>,
     I: CacheIssuer,
 {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         if self.skipper.skipped(req, depot) {
             return;
         }
@@ -309,7 +327,11 @@ where
                 return;
             }
         };
-        let CachedEntry { status, headers, body } = cache;
+        let CachedEntry {
+            status,
+            headers,
+            body,
+        } = cache;
         if let Some(status) = status {
             res.status_code(status);
         }
@@ -328,7 +350,10 @@ mod tests {
 
     #[handler]
     async fn cached() -> String {
-        format!("Hello World, my birth time is {}", OffsetDateTime::now_utc())
+        format!(
+            "Hello World, my birth time is {}",
+            OffsetDateTime::now_utc()
+        )
     }
 
     #[tokio::test]
@@ -342,19 +367,25 @@ mod tests {
         let router = Router::new().hoop(cache).goal(cached);
         let service = Service::new(router);
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let content0 = res.take_string().await.unwrap();
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let content1 = res.take_string().await.unwrap();
         assert_eq!(content0, content1);
 
         tokio::time::sleep(tokio::time::Duration::from_secs(6)).await;
-        let mut res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         let content2 = res.take_string().await.unwrap();
 
         assert_ne!(content0, content2);
diff --git a/crates/compression/src/lib.rs b/crates/compression/src/lib.rs
index 0845318c3..b97ca3e64 100644
--- a/crates/compression/src/lib.rs
+++ b/crates/compression/src/lib.rs
@@ -10,7 +10,9 @@ use std::str::FromStr;
 use indexmap::IndexMap;
 
 use salvo_core::http::body::ResBody;
-use salvo_core::http::header::{HeaderValue, ACCEPT_ENCODING, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE};
+use salvo_core::http::header::{
+    HeaderValue, ACCEPT_ENCODING, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE,
+};
 use salvo_core::http::{self, mime, Mime, StatusCode};
 use salvo_core::{async_trait, Depot, FlowCtrl, Handler, Request, Response};
 
@@ -264,7 +266,11 @@ impl Compression {
         self
     }
 
-    fn negotiate(&self, req: &Request, res: &Response) -> Option<(CompressionAlgo, CompressionLevel)> {
+    fn negotiate(
+        &self,
+        req: &Request,
+        res: &Response,
+    ) -> Option<(CompressionAlgo, CompressionLevel)> {
         if req.headers().contains_key(&CONTENT_ENCODING) {
             return None;
         }
@@ -289,7 +295,10 @@ impl Compression {
                 return None;
             }
         }
-        let header = req.headers().get(ACCEPT_ENCODING).and_then(|v| v.to_str().ok())?;
+        let header = req
+            .headers()
+            .get(ACCEPT_ENCODING)
+            .and_then(|v| v.to_str().ok())?;
 
         let accept_algos = http::parse_accept_encoding(header)
             .into_iter()
@@ -302,7 +311,10 @@ impl Compression {
             })
             .collect::<Vec<_>>();
         if self.force_priority {
-            let accept_algos = accept_algos.into_iter().map(|(algo, _)| algo).collect::<Vec<_>>();
+            let accept_algos = accept_algos
+                .into_iter()
+                .map(|(algo, _)| algo)
+                .collect::<Vec<_>>();
             self.algos
                 .iter()
                 .find(|(algo, _level)| accept_algos.contains(algo))
@@ -317,7 +329,13 @@ impl Compression {
 
 #[async_trait]
 impl Handler for Compression {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         ctrl.call_next(req, depot, res).await;
         if ctrl.is_ceased() || res.headers().contains_key(CONTENT_ENCODING) {
             return;
diff --git a/crates/compression/src/stream.rs b/crates/compression/src/stream.rs
index 6fa8bab2e..aa73e16ed 100644
--- a/crates/compression/src/stream.rs
+++ b/crates/compression/src/stream.rs
@@ -37,7 +37,8 @@ impl<B> EncodeStream<B> {
 impl EncodeStream<BoxStream<'static, Result<Bytes, BoxedError>>> {
     #[inline]
     fn poll_chunk(&mut self, cx: &mut Context<'_>) -> Poll<Option<IoResult<Bytes>>> {
-        Stream::poll_next(Pin::new(&mut self.body), cx).map_err(|e| IoError::new(ErrorKind::Other, e))
+        Stream::poll_next(Pin::new(&mut self.body), cx)
+            .map_err(|e| IoError::new(ErrorKind::Other, e))
     }
 }
 impl EncodeStream<BoxStream<'static, Result<BytesFrame, BoxedError>>> {
diff --git a/crates/core/src/catcher.rs b/crates/core/src/catcher.rs
index 01d1d74df..6ad79a074 100644
--- a/crates/core/src/catcher.rs
+++ b/crates/core/src/catcher.rs
@@ -103,7 +103,10 @@ impl Catcher {
         H: Handler,
         F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static,
     {
-        self.hoops.push(Arc::new(WhenHoop { inner: hoop, filter }));
+        self.hoops.push(Arc::new(WhenHoop {
+            inner: hoop,
+            filter,
+        }));
         self
     }
 
@@ -146,15 +149,29 @@ impl DefaultGoal {
 }
 #[async_trait]
 impl Handler for DefaultGoal {
-    async fn handle(&self, req: &mut Request, _depot: &mut Depot, res: &mut Response, _ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        _depot: &mut Depot,
+        res: &mut Response,
+        _ctrl: &mut FlowCtrl,
+    ) {
         let status = res.status_code.unwrap_or(StatusCode::NOT_FOUND);
-        if (status.is_server_error() || status.is_client_error()) && (res.body.is_none() || res.body.is_error()) {
+        if (status.is_server_error() || status.is_client_error())
+            && (res.body.is_none() || res.body.is_error())
+        {
             write_error_default(req, res, self.footer.as_deref());
         }
     }
 }
 
-fn status_error_html(code: StatusCode, name: &str, brief: &str, cause: Option<&str>, footer: Option<&str>) -> String {
+fn status_error_html(
+    code: StatusCode,
+    name: &str,
+    brief: &str,
+    cause: Option<&str>,
+    footer: Option<&str>,
+) -> String {
     format!(
         r#"<!DOCTYPE html>
 <html>
@@ -253,7 +270,11 @@ fn status_error_xml(code: StatusCode, name: &str, brief: &str, cause: Option<&st
 /// Create bytes from `StatusError`.
 #[doc(hidden)]
 #[inline]
-pub fn status_error_bytes(err: &StatusError, prefer_format: &Mime, footer: Option<&str>) -> (Mime, Bytes) {
+pub fn status_error_bytes(
+    err: &StatusError,
+    prefer_format: &Mime,
+    footer: Option<&str>,
+) -> (Mime, Bytes) {
     let format = if !SUPPORTED_FORMATS.contains(&prefer_format.subtype()) {
         mime::TEXT_HTML
     } else {
@@ -309,7 +330,13 @@ mod tests {
     }
 
     #[handler]
-    async fn handle404(&self, _req: &Request, _depot: &Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle404(
+        &self,
+        _req: &Request,
+        _depot: &Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         if res.status_code.is_none() || Some(StatusCode::NOT_FOUND) == res.status_code {
             res.render("Custom 404 Error Page");
             ctrl.skip_rest();
diff --git a/crates/core/src/conn/joined.rs b/crates/core/src/conn/joined.rs
index e6c4a3d23..c8ddf0c20 100644
--- a/crates/core/src/conn/joined.rs
+++ b/crates/core/src/conn/joined.rs
@@ -29,7 +29,11 @@ where
     B: AsyncRead + Send + Unpin + 'static,
 {
     #[inline]
-    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<IoResult<()>> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<IoResult<()>> {
         match &mut self.get_mut() {
             JoinedStream::A(a) => Pin::new(a).poll_read(cx, buf),
             JoinedStream::B(b) => Pin::new(b).poll_read(cx, buf),
@@ -95,7 +99,12 @@ where
     async fn try_bind(self) -> crate::Result<Self::Acceptor> {
         let a = self.a.try_bind().await?;
         let b = self.b.try_bind().await?;
-        let holdings = a.holdings().iter().chain(b.holdings().iter()).cloned().collect();
+        let holdings = a
+            .holdings()
+            .iter()
+            .chain(b.holdings().iter())
+            .cloned()
+            .collect();
         Ok(JoinedAcceptor { a, b, holdings })
     }
 }
@@ -148,7 +157,10 @@ where
     }
 
     #[inline]
-    async fn accept(&mut self, fuse_factory: Option<ArcFuseFactory>) -> IoResult<Accepted<Self::Conn>> {
+    async fn accept(
+        &mut self,
+        fuse_factory: Option<ArcFuseFactory>,
+    ) -> IoResult<Accepted<Self::Conn>> {
         tokio::select! {
             accepted = self.a.accept(fuse_factory.clone()) => {
                 Ok(accepted?.map_conn(JoinedStream::A))
@@ -173,7 +185,10 @@ mod tests {
         let addr1 = std::net::SocketAddr::from(([127, 0, 0, 1], 6978));
         let addr2 = std::net::SocketAddr::from(([127, 0, 0, 1], 6979));
 
-        let mut acceptor = TcpListener::new(addr1).join(TcpListener::new(addr2)).bind().await;
+        let mut acceptor = TcpListener::new(addr1)
+            .join(TcpListener::new(addr2))
+            .bind()
+            .await;
         tokio::spawn(async move {
             let mut stream = TcpStream::connect(addr1).await.unwrap();
             stream.write_i32(50).await.unwrap();
diff --git a/crates/core/src/conn/proto.rs b/crates/core/src/conn/proto.rs
index 94a668f97..3a62cd663 100644
--- a/crates/core/src/conn/proto.rs
+++ b/crates/core/src/conn/proto.rs
@@ -102,7 +102,11 @@ impl HttpBuilder {
         match version {
             Version::HTTP_10 | Version::HTTP_11 => {
                 #[cfg(not(feature = "http1"))]
-                return Err(std::io::Error::new(std::io::ErrorKind::Other, "http1 feature not enabled").into());
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "http1 feature not enabled",
+                )
+                .into());
                 #[cfg(feature = "http1")]
                 {
                     let mut conn = self
@@ -163,7 +167,11 @@ impl HttpBuilder {
             }
             Version::HTTP_2 => {
                 #[cfg(not(feature = "http2"))]
-                return Err(std::io::Error::new(std::io::ErrorKind::Other, "http2 feature not enabled").into());
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "http2 feature not enabled",
+                )
+                .into());
                 #[cfg(feature = "http2")]
                 {
                     let mut conn = self.http2.serve_connection(TokioIo::new(socket), service);
@@ -305,7 +313,11 @@ impl<T> AsyncRead for Rewind<T>
 where
     T: AsyncRead + Unpin,
 {
-    fn poll_read(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<IoResult<()>> {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<IoResult<()>> {
         if let Some(mut prefix) = self.pre.take() {
             // If there are no remaining bytes, let the bytes get dropped.
             if !prefix.is_empty() {
@@ -328,7 +340,11 @@ impl<T> AsyncWrite for Rewind<T>
 where
     T: AsyncWrite + Unpin,
 {
-    fn poll_write(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>, buf: &[u8]) -> Poll<IoResult<usize>> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &[u8],
+    ) -> Poll<IoResult<usize>> {
         Pin::new(&mut self.inner).poll_write(cx, buf)
     }
 
diff --git a/crates/core/src/conn/stream/straight.rs b/crates/core/src/conn/stream/straight.rs
index 2972d55fd..8f0bda479 100644
--- a/crates/core/src/conn/stream/straight.rs
+++ b/crates/core/src/conn/stream/straight.rs
@@ -59,7 +59,11 @@ impl<C> AsyncRead for StraightStream<C>
 where
     C: AsyncRead,
 {
-    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<IoResult<()>> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<IoResult<()>> {
         let this = self.project();
         let remaining = buf.remaining();
         match this.inner.poll_read(cx, buf) {
@@ -119,7 +123,11 @@ where
         this.inner.poll_shutdown(cx)
     }
 
-    fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>]) -> Poll<IoResult<usize>> {
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<IoResult<usize>> {
         let this = self.project();
         if let Some(fusewire) = &this.fusewire {
             fusewire.event(FuseEvent::Alive);
diff --git a/crates/core/src/conn/tcp.rs b/crates/core/src/conn/tcp.rs
index 87f9af2b9..31d9b6572 100644
--- a/crates/core/src/conn/tcp.rs
+++ b/crates/core/src/conn/tcp.rs
@@ -40,7 +40,10 @@ impl<T: ToSocketAddrs + Send> TcpListener<T> {
     #[inline]
     pub fn new(local_addr: T) -> Self {
         #[cfg(not(feature = "socket2"))]
-        TcpListener { local_addr, ttl: None }
+        TcpListener {
+            local_addr,
+            ttl: None,
+        }
     }
     /// Bind to socket address.
     #[cfg(feature = "socket2")]
@@ -207,7 +210,10 @@ impl Acceptor for TcpAcceptor {
     }
 
     #[inline]
-    async fn accept(&mut self, fuse_factory: Option<ArcFuseFactory>) -> IoResult<Accepted<Self::Conn>> {
+    async fn accept(
+        &mut self,
+        fuse_factory: Option<ArcFuseFactory>,
+    ) -> IoResult<Accepted<Self::Conn>> {
         self.inner.accept().await.map(move |(conn, remote_addr)| {
             let local_addr = self.holdings[0].local_addr.clone();
             Accepted {
@@ -239,7 +245,11 @@ mod tests {
     async fn test_tcp_listener() {
         let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 6878));
         let mut acceptor = TcpListener::new(addr).bind().await;
-        let addr = acceptor.holdings()[0].local_addr.clone().into_std().unwrap();
+        let addr = acceptor.holdings()[0]
+            .local_addr
+            .clone()
+            .into_std()
+            .unwrap();
         tokio::spawn(async move {
             let mut stream = TcpStream::connect(addr).await.unwrap();
             stream.write_i32(150).await.unwrap();
diff --git a/crates/core/src/depot.rs b/crates/core/src/depot.rs
index 1e27ec61e..ef29de5ca 100644
--- a/crates/core/src/depot.rs
+++ b/crates/core/src/depot.rs
@@ -47,7 +47,9 @@ impl Depot {
     /// The depot is initially created with a capacity of 0, so it will not allocate until it is first inserted into.
     #[inline]
     pub fn new() -> Depot {
-        Depot { map: HashMap::new() }
+        Depot {
+            map: HashMap::new(),
+        }
     }
 
     /// Get reference to depot inner map.
@@ -92,7 +94,9 @@ impl Depot {
     /// Returns `Err(None)` if value is not present in depot.
     /// Returns `Err(Some(Box<dyn Any + Send + Sync>))` if value is present in depot but downcast failed.
     #[inline]
-    pub fn obtain_mut<T: Any + Send + Sync>(&mut self) -> Result<&mut T, Option<&mut Box<dyn Any + Send + Sync>>> {
+    pub fn obtain_mut<T: Any + Send + Sync>(
+        &mut self,
+    ) -> Result<&mut T, Option<&mut Box<dyn Any + Send + Sync>>> {
         self.get_mut(&type_key::<T>())
     }
 
@@ -125,7 +129,10 @@ impl Depot {
     /// Returns `Err(None)` if value is not present in depot.
     /// Returns `Err(Some(Box<dyn Any + Send + Sync>))` if value is present in depot but downcast failed.
     #[inline]
-    pub fn get<V: Any + Send + Sync>(&self, key: &str) -> Result<&V, Option<&Box<dyn Any + Send + Sync>>> {
+    pub fn get<V: Any + Send + Sync>(
+        &self,
+        key: &str,
+    ) -> Result<&V, Option<&Box<dyn Any + Send + Sync>>> {
         if let Some(value) = self.map.get(key) {
             value.downcast_ref::<V>().ok_or(Some(value))
         } else {
@@ -143,7 +150,9 @@ impl Depot {
     ) -> Result<&mut V, Option<&mut Box<dyn Any + Send + Sync>>> {
         if let Some(value) = self.map.get_mut(key) {
             if value.downcast_mut::<V>().is_some() {
-                Ok(value.downcast_mut::<V>().expect("downcast_mut shuold not be failed"))
+                Ok(value
+                    .downcast_mut::<V>()
+                    .expect("downcast_mut shuold not be failed"))
             } else {
                 Err(Some(value))
             }
@@ -154,7 +163,10 @@ impl Depot {
 
     /// Remove value from depot and returning the value at the key if the key was previously in the depot.
     #[inline]
-    pub fn remove<V: Any + Send + Sync>(&mut self, key: &str) -> Result<V, Option<Box<dyn Any + Send + Sync>>> {
+    pub fn remove<V: Any + Send + Sync>(
+        &mut self,
+        key: &str,
+    ) -> Result<V, Option<Box<dyn Any + Send + Sync>>> {
         if let Some(value) = self.map.remove(key) {
             value.downcast::<V>().map(|b| *b).map_err(Some)
         } else {
@@ -170,14 +182,18 @@ impl Depot {
 
     /// Remove value from depot and returning the value if the type was previously in the depot.
     #[inline]
-    pub fn scrape<T: Any + Send + Sync>(&mut self) -> Result<T, Option<Box<dyn Any + Send + Sync>>> {
+    pub fn scrape<T: Any + Send + Sync>(
+        &mut self,
+    ) -> Result<T, Option<Box<dyn Any + Send + Sync>>> {
         self.remove(&type_key::<T>())
     }
 }
 
 impl fmt::Debug for Depot {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Depot").field("keys", &self.map.keys()).finish()
+        f.debug_struct("Depot")
+            .field("keys", &self.map.keys())
+            .finish()
     }
 }
 
@@ -197,19 +213,30 @@ mod test {
         assert!(depot.contains_key("one"));
 
         assert_eq!(depot.get::<String>("one").unwrap(), &"ONE".to_owned());
-        assert_eq!(depot.get_mut::<String>("one").unwrap(), &mut "ONE".to_owned());
+        assert_eq!(
+            depot.get_mut::<String>("one").unwrap(),
+            &mut "ONE".to_owned()
+        );
     }
 
     #[tokio::test]
     async fn test_middleware_use_depot() {
         #[handler]
-        async fn set_user(req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+        async fn set_user(
+            req: &mut Request,
+            depot: &mut Depot,
+            res: &mut Response,
+            ctrl: &mut FlowCtrl,
+        ) {
             depot.insert("user", "client");
             ctrl.call_next(req, depot, res).await;
         }
         #[handler]
         async fn hello(depot: &mut Depot) -> String {
-            format!("Hello {}", depot.get::<&str>("user").copied().unwrap_or_default())
+            format!(
+                "Hello {}",
+                depot.get::<&str>("user").copied().unwrap_or_default()
+            )
         }
         let router = Router::new().hoop(set_user).goal(hello);
         let service = Service::new(router);
diff --git a/crates/core/src/extract/case.rs b/crates/core/src/extract/case.rs
index f961240b0..ab3fb8af2 100644
--- a/crates/core/src/extract/case.rs
+++ b/crates/core/src/extract/case.rs
@@ -68,7 +68,9 @@ impl RenameRule {
             }
             ScreamingSnakeCase => SnakeCase.apply_to_variant(variant).to_ascii_uppercase(),
             KebabCase => SnakeCase.apply_to_variant(variant).replace('_', "-"),
-            ScreamingKebabCase => ScreamingSnakeCase.apply_to_variant(variant).replace('_', "-"),
+            ScreamingKebabCase => ScreamingSnakeCase
+                .apply_to_variant(variant)
+                .replace('_', "-"),
         }
     }
 
@@ -111,7 +113,8 @@ mod tests {
     fn test_rename_variants() {
         for &(original, lower, upper, camel, snake, screaming, kebab, screaming_kebab) in &[
             (
-                "Outcome", "outcome", "OUTCOME", "outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
+                "Outcome", "outcome", "OUTCOME", "outcome", "outcome", "OUTCOME", "outcome",
+                "OUTCOME",
             ),
             (
                 "VeryTasty",
@@ -133,7 +136,10 @@ mod tests {
             assert_eq!(SnakeCase.apply_to_variant(original), snake);
             assert_eq!(ScreamingSnakeCase.apply_to_variant(original), screaming);
             assert_eq!(KebabCase.apply_to_variant(original), kebab);
-            assert_eq!(ScreamingKebabCase.apply_to_variant(original), screaming_kebab);
+            assert_eq!(
+                ScreamingKebabCase.apply_to_variant(original),
+                screaming_kebab
+            );
         }
     }
 
diff --git a/crates/core/src/extract/metadata.rs b/crates/core/src/extract/metadata.rs
index 9d66383d6..eeac85786 100644
--- a/crates/core/src/extract/metadata.rs
+++ b/crates/core/src/extract/metadata.rs
@@ -31,7 +31,9 @@ impl FromStr for SourceFrom {
             #[cfg(feature = "cookie")]
             "cookie" => Ok(Self::Cookie),
             "body" => Ok(Self::Body),
-            _ => Err(crate::Error::Other(format!("invalid source from `{input}`").into())),
+            _ => Err(crate::Error::Other(
+                format!("invalid source from `{input}`").into(),
+            )),
         }
     }
 }
@@ -130,7 +132,11 @@ impl Metadata {
 
     /// Check is this type has body required.
     pub(crate) fn has_body_required(&self) -> bool {
-        if self.default_sources.iter().any(|s| s.from == SourceFrom::Body) {
+        if self
+            .default_sources
+            .iter()
+            .any(|s| s.from == SourceFrom::Body)
+        {
             return true;
         }
         self.fields.iter().any(|f| f.has_body_required())
@@ -260,7 +266,10 @@ mod tests {
 
     #[test]
     fn test_parse_source_format() {
-        for (key, value) in [("multimap", SourceParser::MultiMap), ("json", SourceParser::Json)] {
+        for (key, value) in [
+            ("multimap", SourceParser::MultiMap),
+            ("json", SourceParser::Json),
+        ] {
             assert_eq!(key.parse::<SourceParser>().unwrap(), value);
         }
         assert!("abcd".parse::<SourceParser>().is_err());
diff --git a/crates/core/src/fs/mod.rs b/crates/core/src/fs/mod.rs
index 604588e08..27d16ec6a 100644
--- a/crates/core/src/fs/mod.rs
+++ b/crates/core/src/fs/mod.rs
@@ -41,8 +41,13 @@ where
 
         match self.state {
             ChunkedState::File(ref mut file) => {
-                let mut file = file.take().expect("`ChunkedReadFile` polled after completion");
-                let max_bytes = cmp::min(self.total_size.saturating_sub(self.read_size), self.buffer_size) as usize;
+                let mut file = file
+                    .take()
+                    .expect("`ChunkedReadFile` polled after completion");
+                let max_bytes = cmp::min(
+                    self.total_size.saturating_sub(self.read_size),
+                    self.buffer_size,
+                ) as usize;
                 let offset = self.offset;
                 let fut = tokio::task::spawn_blocking(move || {
                     let mut buf = Vec::with_capacity(max_bytes);
@@ -58,8 +63,8 @@ where
                 self.poll_next(cx)
             }
             ChunkedState::Future(ref mut fut) => {
-                let (file, bytes) =
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| IoError::new(ErrorKind::Other, "BlockingErr"))??;
+                let (file, bytes) = ready!(Pin::new(fut).poll(cx))
+                    .map_err(|_| IoError::new(ErrorKind::Other, "BlockingErr"))??;
                 self.state = ChunkedState::File(Some(file));
 
                 self.offset += bytes.len() as u64;
@@ -121,7 +126,9 @@ mod test {
         assert_eq!(file.content_type(), &Mime::from_str("text/html").unwrap());
         assert_eq!(
             file.content_disposition(),
-            Some(&HeaderValue::from_static("attachment; filename=attach.file"))
+            Some(&HeaderValue::from_static(
+                "attachment; filename=attach.file"
+            ))
         );
     }
 }
diff --git a/crates/core/src/fs/named_file.rs b/crates/core/src/fs/named_file.rs
index 189012819..540710c21 100644
--- a/crates/core/src/fs/named_file.rs
+++ b/crates/core/src/fs/named_file.rs
@@ -170,7 +170,9 @@ impl NamedFileBuilder {
                 && ct.get_param(mime::CHARSET).is_none()
             {
                 //TODO: auto detect charset
-                format!("{ct}; charset=utf-8").parse::<mime::Mime>().unwrap_or(ct)
+                format!("{ct}; charset=utf-8")
+                    .parse::<mime::Mime>()
+                    .unwrap_or(ct)
             } else {
                 ct
             }
@@ -178,7 +180,11 @@ impl NamedFileBuilder {
         let metadata = file.metadata().await?;
         let modified = metadata.modified().ok();
         let content_encoding = match content_encoding {
-            Some(content_encoding) => Some(content_encoding.parse::<HeaderValue>().map_err(Error::other)?),
+            Some(content_encoding) => Some(
+                content_encoding
+                    .parse::<HeaderValue>()
+                    .map_err(Error::other)?,
+            ),
             None => None,
         };
 
@@ -215,9 +221,8 @@ fn build_content_disposition(
             "attachment"
         } else {
             match (content_type.type_(), content_type.subtype()) {
-                (mime::IMAGE | mime::TEXT | mime::VIDEO | mime::AUDIO, _) | (_, mime::JAVASCRIPT | mime::JSON) => {
-                    "inline"
-                }
+                (mime::IMAGE | mime::TEXT | mime::VIDEO | mime::AUDIO, _)
+                | (_, mime::JAVASCRIPT | mime::JSON) => "inline",
                 _ => "attachment",
             }
         }
@@ -236,7 +241,9 @@ fn build_content_disposition(
             .parse::<HeaderValue>()
             .map_err(Error::other)?
     } else {
-        disposition_type.parse::<HeaderValue>().map_err(Error::other)?
+        disposition_type
+            .parse::<HeaderValue>()
+            .map_err(Error::other)?
     };
     Ok(content_disposition)
 }
@@ -427,7 +434,8 @@ impl NamedFile {
             true
         } else if req_headers.contains_key(IF_NONE_MATCH) {
             false
-        } else if let (Some(last_modified), Some(since)) = (&last_modified, req_headers.typed_get::<IfModifiedSince>())
+        } else if let (Some(last_modified), Some(since)) =
+            (&last_modified, req_headers.typed_get::<IfModifiedSince>())
         {
             !since.is_modified(*last_modified)
         } else {
@@ -436,12 +444,14 @@ impl NamedFile {
 
         if self.flags.contains(Flag::ContentDisposition) {
             if let Some(content_disposition) = self.content_disposition.take() {
-                res.headers_mut().insert(CONTENT_DISPOSITION, content_disposition);
+                res.headers_mut()
+                    .insert(CONTENT_DISPOSITION, content_disposition);
             } else if !res.headers().contains_key(CONTENT_DISPOSITION) {
                 // skip to set CONTENT_DISPOSITION header if it is already set.
                 match build_content_disposition(&self.path, &self.content_type, None, None) {
                     Ok(content_disposition) => {
-                        res.headers_mut().insert(CONTENT_DISPOSITION, content_disposition);
+                        res.headers_mut()
+                            .insert(CONTENT_DISPOSITION, content_disposition);
                     }
                     Err(e) => {
                         tracing::error!(error = ?e, "build file's content disposition failed");
@@ -462,7 +472,8 @@ impl NamedFile {
 
         let mut length = self.metadata.len();
         if let Some(content_encoding) = &self.content_encoding {
-            res.headers_mut().insert(CONTENT_ENCODING, content_encoding.clone());
+            res.headers_mut()
+                .insert(CONTENT_ENCODING, content_encoding.clone());
         }
         let mut offset = 0;
 
@@ -474,7 +485,8 @@ impl NamedFile {
                     length = range[0].length;
                     offset = range[0].start;
                 } else {
-                    res.headers_mut().typed_insert(ContentRange::unsatisfied_bytes(length));
+                    res.headers_mut()
+                        .typed_insert(ContentRange::unsatisfied_bytes(length));
                     res.status_code(StatusCode::RANGE_NOT_SATISFIABLE);
                     return;
                 };
@@ -509,7 +521,8 @@ impl NamedFile {
                 state: ChunkedState::File(Some(self.file.into_std().await)),
                 buffer_size: self.buffer_size,
             };
-            res.headers_mut().typed_insert(ContentLength(reader.total_size));
+            res.headers_mut()
+                .typed_insert(ContentLength(reader.total_size));
             res.stream(reader);
         } else {
             res.status_code(StatusCode::OK);
diff --git a/crates/core/src/fuse/flex.rs b/crates/core/src/fuse/flex.rs
index b4a73aade..2570da4eb 100644
--- a/crates/core/src/fuse/flex.rs
+++ b/crates/core/src/fuse/flex.rs
@@ -106,9 +106,12 @@ impl Fusewire for FlexFusewire {
                 let tls_handshake_token = self.tls_handshake_token.clone();
                 tokio::spawn(async move {
                     loop {
-                        if tokio::time::timeout(tls_handshake_timeout, tls_handshake_notify.notified())
-                            .await
-                            .is_err()
+                        if tokio::time::timeout(
+                            tls_handshake_timeout,
+                            tls_handshake_notify.notified(),
+                        )
+                        .await
+                        .is_err()
                         {
                             tls_handshake_token.cancel();
                             break;
diff --git a/crates/core/src/handler.rs b/crates/core/src/handler.rs
index 6f9b47d58..e6e65a6ee 100644
--- a/crates/core/src/handler.rs
+++ b/crates/core/src/handler.rs
@@ -137,7 +137,13 @@ pub trait Handler: Send + Sync + 'static {
     }
     /// Handle http request.
     #[must_use = "handle future must be used"]
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl);
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    );
 
     /// Wrap to `HoopedHandler`.
     #[inline]
@@ -175,7 +181,13 @@ pub trait Handler: Send + Sync + 'static {
 pub struct EmptyHandler;
 #[async_trait]
 impl Handler for EmptyHandler {
-    async fn handle(&self, _req: &mut Request, _depot: &mut Depot, res: &mut Response, _ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        _req: &mut Request,
+        _depot: &mut Depot,
+        res: &mut Response,
+        _ctrl: &mut FlowCtrl,
+    ) {
         res.status_code(StatusCode::OK);
     }
 }
@@ -204,7 +216,13 @@ where
     H: Handler,
     F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static,
 {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         if (self.filter)(req, depot) {
             self.inner.handle(req, depot, res, ctrl).await;
         }
@@ -275,7 +293,13 @@ impl HoopedHandler {
 }
 #[async_trait]
 impl Handler for HoopedHandler {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, _ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        _ctrl: &mut FlowCtrl,
+    ) {
         let inner: Arc<dyn Handler> = self.inner.clone();
         let mut ctrl = FlowCtrl::new(self.hoops.iter().chain([&inner]).cloned().collect());
         ctrl.call_next(req, depot, res).await;
diff --git a/crates/core/src/http/body/channel.rs b/crates/core/src/http/body/channel.rs
index 4bca62e72..c3f9c542b 100644
--- a/crates/core/src/http/body/channel.rs
+++ b/crates/core/src/http/body/channel.rs
@@ -79,17 +79,18 @@ impl BodySender {
 }
 
 impl futures_util::AsyncWrite for BodySender {
-    fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<IoResult<usize>> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<IoResult<usize>> {
         match self.data_tx.poll_ready(cx) {
             Poll::Ready(Ok(())) => {
                 let data: Bytes = Bytes::from(buf.to_vec());
                 let len = buf.len();
-                Poll::Ready(
-                    self.data_tx
-                        .try_send(Ok(data))
-                        .map(|_| len)
-                        .map_err(|e| IoError::new(ErrorKind::Other, format!("failed to send data: {}", e))),
-                )
+                Poll::Ready(self.data_tx.try_send(Ok(data)).map(|_| len).map_err(|e| {
+                    IoError::new(ErrorKind::Other, format!("failed to send data: {}", e))
+                }))
             }
             Poll::Ready(Err(e)) => Poll::Ready(Err(IoError::new(
                 ErrorKind::Other,
@@ -113,17 +114,18 @@ impl futures_util::AsyncWrite for BodySender {
 }
 
 impl tokio::io::AsyncWrite for BodySender {
-    fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<IoResult<usize>> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<IoResult<usize>> {
         match self.data_tx.poll_ready(cx) {
             Poll::Ready(Ok(())) => {
                 let data: Bytes = Bytes::from(buf.to_vec());
                 let len = buf.len();
-                Poll::Ready(
-                    self.data_tx
-                        .try_send(Ok(data))
-                        .map(|_| len)
-                        .map_err(|e| IoError::new(ErrorKind::Other, format!("failed to send data: {}", e))),
-                )
+                Poll::Ready(self.data_tx.try_send(Ok(data)).map(|_| len).map_err(|e| {
+                    IoError::new(ErrorKind::Other, format!("failed to send data: {}", e))
+                }))
             }
             Poll::Ready(Err(e)) => Poll::Ready(Err(IoError::new(
                 ErrorKind::Other,
diff --git a/crates/core/src/http/body/req.rs b/crates/core/src/http/body/req.rs
index 4f795b7d6..ac8aaf092 100644
--- a/crates/core/src/http/body/req.rs
+++ b/crates/core/src/http/body/req.rs
@@ -11,7 +11,8 @@ use bytes::Bytes;
 use crate::fuse::{ArcFusewire, FuseEvent};
 use crate::BoxedError;
 
-pub(crate) type BoxedBody = Pin<Box<dyn Body<Data = Bytes, Error = BoxedError> + Send + Sync + 'static>>;
+pub(crate) type BoxedBody =
+    Pin<Box<dyn Body<Data = Bytes, Error = BoxedError> + Send + Sync + 'static>>;
 pub(crate) type PollFrame = Poll<Option<Result<Frame<Bytes>, IoError>>>;
 
 /// Body for HTTP request.
@@ -167,7 +168,10 @@ impl From<Bytes> for ReqBody {
 }
 impl From<Incoming> for ReqBody {
     fn from(inner: Incoming) -> Self {
-        Self::Hyper { inner, fusewire: None }
+        Self::Hyper {
+            inner,
+            fusewire: None,
+        }
     }
 }
 impl From<String> for ReqBody {
@@ -180,10 +184,16 @@ impl TryFrom<ReqBody> for Incoming {
     type Error = crate::Error;
     fn try_from(body: ReqBody) -> Result<Self, Self::Error> {
         match body {
-            ReqBody::None => Err(crate::Error::other("ReqBody::None cannot convert to Incoming")),
-            ReqBody::Once(_) => Err(crate::Error::other("ReqBody::Bytes cannot convert to Incoming")),
+            ReqBody::None => Err(crate::Error::other(
+                "ReqBody::None cannot convert to Incoming",
+            )),
+            ReqBody::Once(_) => Err(crate::Error::other(
+                "ReqBody::Bytes cannot convert to Incoming",
+            )),
             ReqBody::Hyper { inner, .. } => Ok(inner),
-            ReqBody::Boxed { .. } => Err(crate::Error::other("ReqBody::Boxed cannot convert to Incoming")),
+            ReqBody::Boxed { .. } => Err(crate::Error::other(
+                "ReqBody::Boxed cannot convert to Incoming",
+            )),
         }
     }
 }
@@ -293,7 +303,10 @@ impl fmt::Debug for ReqBody {
         match self {
             ReqBody::None => write!(f, "ReqBody::None"),
             ReqBody::Once(value) => f.debug_tuple("ReqBody::Once").field(value).finish(),
-            ReqBody::Hyper { inner, .. } => f.debug_struct("ReqBody::Hyper").field("inner", inner).finish(),
+            ReqBody::Hyper { inner, .. } => f
+                .debug_struct("ReqBody::Hyper")
+                .field("inner", inner)
+                .finish(),
             ReqBody::Boxed { .. } => write!(f, "ReqBody::Boxed{{..}}"),
         }
     }
diff --git a/crates/core/src/http/body/res.rs b/crates/core/src/http/body/res.rs
index 103c17905..cef706b5b 100644
--- a/crates/core/src/http/body/res.rs
+++ b/crates/core/src/http/body/res.rs
@@ -102,7 +102,10 @@ impl ResBody {
             data_tx,
             trailers_tx: Some(trailers_tx),
         };
-        let rx = ResBody::Channel(BodyReceiver { data_rx, trailers_rx });
+        let rx = ResBody::Channel(BodyReceiver {
+            data_rx,
+            trailers_rx,
+        });
 
         (tx, rx)
     }
@@ -147,16 +150,22 @@ impl Body for ResBody {
                     Poll::Ready(Some(Ok(Frame::data(bytes))))
                 }
             }
-            Self::Chunks(chunks) => Poll::Ready(chunks.pop_front().map(|bytes| Ok(Frame::data(bytes)))),
+            Self::Chunks(chunks) => {
+                Poll::Ready(chunks.pop_front().map(|bytes| Ok(Frame::data(bytes))))
+            }
             Self::Hyper(body) => match Body::poll_frame(Pin::new(body), cx) {
                 Poll::Ready(Some(Ok(frame))) => Poll::Ready(Some(Ok(frame))),
-                Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(IoError::new(ErrorKind::Other, e)))),
+                Poll::Ready(Some(Err(e))) => {
+                    Poll::Ready(Some(Err(IoError::new(ErrorKind::Other, e))))
+                }
                 Poll::Ready(None) => Poll::Ready(None),
                 Poll::Pending => Poll::Pending,
             },
             Self::Boxed(body) => match Body::poll_frame(Pin::new(body), cx) {
                 Poll::Ready(Some(Ok(frame))) => Poll::Ready(Some(Ok(frame))),
-                Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(IoError::new(ErrorKind::Other, e)))),
+                Poll::Ready(Some(Err(e))) => {
+                    Poll::Ready(Some(Err(IoError::new(ErrorKind::Other, e))))
+                }
                 Poll::Ready(None) => Poll::Ready(None),
                 Poll::Pending => Poll::Pending,
             },
diff --git a/crates/core/src/http/errors/parse_error.rs b/crates/core/src/http/errors/parse_error.rs
index 40ef6e36d..cd8c8dddb 100644
--- a/crates/core/src/http/errors/parse_error.rs
+++ b/crates/core/src/http/errors/parse_error.rs
@@ -104,7 +104,11 @@ impl ParseError {
 #[async_trait]
 impl Writer for ParseError {
     async fn write(self, _req: &mut Request, _depot: &mut Depot, res: &mut Response) {
-        res.render(StatusError::bad_request().brief("parse http data failed.").cause(self));
+        res.render(
+            StatusError::bad_request()
+                .brief("parse http data failed.")
+                .cause(self),
+        );
     }
 }
 
diff --git a/crates/core/src/http/errors/status_error.rs b/crates/core/src/http/errors/status_error.rs
index f0b58f90d..973e9eca8 100644
--- a/crates/core/src/http/errors/status_error.rs
+++ b/crates/core/src/http/errors/status_error.rs
@@ -192,7 +192,10 @@ impl StdError for StatusError {}
 
 impl Display for StatusError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let mut str_error = format!("code: {} name: {} brief: {}", self.code, self.name, self.brief);
+        let mut str_error = format!(
+            "code: {} name: {} brief: {}",
+            self.code, self.name, self.brief
+        );
         if let Some(detail) = &self.detail {
             write!(&mut str_error, " detail: {}", detail)?;
         }
@@ -214,7 +217,9 @@ impl StatusError {
             StatusCode::NOT_FOUND => Some(StatusError::not_found()),
             StatusCode::METHOD_NOT_ALLOWED => Some(StatusError::method_not_allowed()),
             StatusCode::NOT_ACCEPTABLE => Some(StatusError::not_acceptable()),
-            StatusCode::PROXY_AUTHENTICATION_REQUIRED => Some(StatusError::proxy_authentication_required()),
+            StatusCode::PROXY_AUTHENTICATION_REQUIRED => {
+                Some(StatusError::proxy_authentication_required())
+            }
             StatusCode::REQUEST_TIMEOUT => Some(StatusError::request_timeout()),
             StatusCode::CONFLICT => Some(StatusError::conflict()),
             StatusCode::GONE => Some(StatusError::gone()),
@@ -233,19 +238,27 @@ impl StatusError {
             StatusCode::UPGRADE_REQUIRED => Some(StatusError::upgrade_required()),
             StatusCode::PRECONDITION_REQUIRED => Some(StatusError::precondition_required()),
             StatusCode::TOO_MANY_REQUESTS => Some(StatusError::too_many_requests()),
-            StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE => Some(StatusError::request_header_fields_toolarge()),
-            StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS => Some(StatusError::unavailable_for_legalreasons()),
+            StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE => {
+                Some(StatusError::request_header_fields_toolarge())
+            }
+            StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS => {
+                Some(StatusError::unavailable_for_legalreasons())
+            }
             StatusCode::INTERNAL_SERVER_ERROR => Some(StatusError::internal_server_error()),
             StatusCode::NOT_IMPLEMENTED => Some(StatusError::not_implemented()),
             StatusCode::BAD_GATEWAY => Some(StatusError::bad_gateway()),
             StatusCode::SERVICE_UNAVAILABLE => Some(StatusError::service_unavailable()),
             StatusCode::GATEWAY_TIMEOUT => Some(StatusError::gateway_timeout()),
-            StatusCode::HTTP_VERSION_NOT_SUPPORTED => Some(StatusError::http_version_not_supported()),
+            StatusCode::HTTP_VERSION_NOT_SUPPORTED => {
+                Some(StatusError::http_version_not_supported())
+            }
             StatusCode::VARIANT_ALSO_NEGOTIATES => Some(StatusError::variant_also_negotiates()),
             StatusCode::INSUFFICIENT_STORAGE => Some(StatusError::insufficient_storage()),
             StatusCode::LOOP_DETECTED => Some(StatusError::loop_detected()),
             StatusCode::NOT_EXTENDED => Some(StatusError::not_extended()),
-            StatusCode::NETWORK_AUTHENTICATION_REQUIRED => Some(StatusError::network_authentication_required()),
+            StatusCode::NETWORK_AUTHENTICATION_REQUIRED => {
+                Some(StatusError::network_authentication_required())
+            }
             _ => None,
         }
     }
diff --git a/crates/core/src/http/form.rs b/crates/core/src/http/form.rs
index c8917413a..7921d9f97 100644
--- a/crates/core/src/http/form.rs
+++ b/crates/core/src/http/form.rs
@@ -50,7 +50,10 @@ impl FormData {
             .and_then(|v| v.parse().ok());
         match ctype {
             Some(ctype) if ctype.subtype() == mime::WWW_FORM_URLENCODED => {
-                let data = BodyExt::collect(body).await.map_err(ParseError::other)?.to_bytes();
+                let data = BodyExt::collect(body)
+                    .await
+                    .map_err(ParseError::other)?
+                    .to_bytes();
                 let mut form_data = FormData::new();
                 form_data.fields = form_urlencoded::parse(&data).into_owned().collect();
                 Ok(form_data)
@@ -67,7 +70,9 @@ impl FormData {
                     while let Some(mut field) = multipart.next_field().await? {
                         if let Some(name) = field.name().map(|s| s.to_owned()) {
                             if field.headers().get(CONTENT_TYPE).is_some() {
-                                form_data.files.insert(name, FilePart::create(&mut field).await?);
+                                form_data
+                                    .files
+                                    .insert(name, FilePart::create(&mut field).await?);
                             } else {
                                 form_data.fields.insert(name, field.text().await?);
                             }
@@ -150,10 +155,11 @@ impl FilePart {
     /// deleted once the FilePart object goes out of scope).
     pub async fn create(field: &mut Field<'_>) -> Result<FilePart, ParseError> {
         // Setup a file to capture the contents.
-        let mut path = tokio::task::spawn_blocking(|| Builder::new().prefix("salvo_http_multipart").tempdir())
-            .await
-            .expect("Runtime spawn blocking poll error")?
-            .into_path();
+        let mut path =
+            tokio::task::spawn_blocking(|| Builder::new().prefix("salvo_http_multipart").tempdir())
+                .await
+                .expect("Runtime spawn blocking poll error")?
+                .into_path();
         let temp_dir = Some(path.clone());
         let name = field.file_name().map(|s| s.to_owned());
         path.push(format!(
diff --git a/crates/core/src/http/mod.rs b/crates/core/src/http/mod.rs
index 62594f20a..19b6a6336 100644
--- a/crates/core/src/http/mod.rs
+++ b/crates/core/src/http/mod.rs
@@ -87,7 +87,12 @@ pub fn parse_accept_encoding(header: &str) -> Vec<(String, u8)> {
 pub fn guess_accept_mime(req: &Request, default_type: Option<Mime>) -> Mime {
     let dmime: Mime = default_type.unwrap_or(mime::TEXT_HTML);
     let accept = req.accept();
-    accept.first().unwrap_or(&dmime).to_string().parse().unwrap_or(dmime)
+    accept
+        .first()
+        .unwrap_or(&dmime)
+        .to_string()
+        .parse()
+        .unwrap_or(dmime)
 }
 
 #[cfg(test)]
diff --git a/crates/core/src/http/range.rs b/crates/core/src/http/range.rs
index ea50628e4..49f3bcee5 100644
--- a/crates/core/src/http/range.rs
+++ b/crates/core/src/http/range.rs
@@ -128,33 +128,116 @@ mod tests {
             T("bytes=0x01-0x02", 10, vec![]),
             T("bytes=         ", 10, vec![]),
             T("bytes= , , ,   ", 10, vec![]),
-            T("bytes=0-9", 10, vec![HttpRange { start: 0, length: 10 }]),
-            T("bytes=0-", 10, vec![HttpRange { start: 0, length: 10 }]),
-            T("bytes=5-", 10, vec![HttpRange { start: 5, length: 5 }]),
-            T("bytes=0-20", 10, vec![HttpRange { start: 0, length: 10 }]),
-            T("bytes=15-,0-5", 10, vec![HttpRange { start: 0, length: 6 }]),
+            T(
+                "bytes=0-9",
+                10,
+                vec![HttpRange {
+                    start: 0,
+                    length: 10,
+                }],
+            ),
+            T(
+                "bytes=0-",
+                10,
+                vec![HttpRange {
+                    start: 0,
+                    length: 10,
+                }],
+            ),
+            T(
+                "bytes=5-",
+                10,
+                vec![HttpRange {
+                    start: 5,
+                    length: 5,
+                }],
+            ),
+            T(
+                "bytes=0-20",
+                10,
+                vec![HttpRange {
+                    start: 0,
+                    length: 10,
+                }],
+            ),
+            T(
+                "bytes=15-,0-5",
+                10,
+                vec![HttpRange {
+                    start: 0,
+                    length: 6,
+                }],
+            ),
             T(
                 "bytes=1-2,5-",
                 10,
-                vec![HttpRange { start: 1, length: 2 }, HttpRange { start: 5, length: 5 }],
+                vec![
+                    HttpRange {
+                        start: 1,
+                        length: 2,
+                    },
+                    HttpRange {
+                        start: 5,
+                        length: 5,
+                    },
+                ],
             ),
             T(
                 "bytes=-2 , 7-",
                 11,
-                vec![HttpRange { start: 9, length: 2 }, HttpRange { start: 7, length: 4 }],
+                vec![
+                    HttpRange {
+                        start: 9,
+                        length: 2,
+                    },
+                    HttpRange {
+                        start: 7,
+                        length: 4,
+                    },
+                ],
             ),
             T(
                 "bytes=0-0 ,2-2, 7-",
                 11,
                 vec![
-                    HttpRange { start: 0, length: 1 },
-                    HttpRange { start: 2, length: 1 },
-                    HttpRange { start: 7, length: 4 },
+                    HttpRange {
+                        start: 0,
+                        length: 1,
+                    },
+                    HttpRange {
+                        start: 2,
+                        length: 1,
+                    },
+                    HttpRange {
+                        start: 7,
+                        length: 4,
+                    },
                 ],
             ),
-            T("bytes=-5", 10, vec![HttpRange { start: 5, length: 5 }]),
-            T("bytes=-15", 10, vec![HttpRange { start: 0, length: 10 }]),
-            T("bytes=0-499", 10000, vec![HttpRange { start: 0, length: 500 }]),
+            T(
+                "bytes=-5",
+                10,
+                vec![HttpRange {
+                    start: 5,
+                    length: 5,
+                }],
+            ),
+            T(
+                "bytes=-15",
+                10,
+                vec![HttpRange {
+                    start: 0,
+                    length: 10,
+                }],
+            ),
+            T(
+                "bytes=0-499",
+                10000,
+                vec![HttpRange {
+                    start: 0,
+                    length: 500,
+                }],
+            ),
             T(
                 "bytes=500-999",
                 10000,
@@ -182,7 +265,16 @@ mod tests {
             T(
                 "bytes=0-0,-1",
                 10000,
-                vec![HttpRange { start: 0, length: 1 }, HttpRange { start: 9999, length: 1 }],
+                vec![
+                    HttpRange {
+                        start: 0,
+                        length: 1,
+                    },
+                    HttpRange {
+                        start: 9999,
+                        length: 1,
+                    },
+                ],
             ),
             T(
                 "bytes=500-600,601-999",
@@ -217,9 +309,18 @@ mod tests {
                 "bytes=   1 -2   ,  4- 5, 7 - 8 , ,,",
                 11,
                 vec![
-                    HttpRange { start: 1, length: 2 },
-                    HttpRange { start: 4, length: 2 },
-                    HttpRange { start: 7, length: 2 },
+                    HttpRange {
+                        start: 1,
+                        length: 2,
+                    },
+                    HttpRange {
+                        start: 4,
+                        length: 2,
+                    },
+                    HttpRange {
+                        start: 7,
+                        length: 2,
+                    },
                 ],
             ),
         ];
@@ -235,7 +336,12 @@ mod tests {
                 if expected.is_empty() {
                     continue;
                 } else {
-                    panic!("parse({}, {}) returned error {:?}", header, size, res.unwrap_err());
+                    panic!(
+                        "parse({}, {}) returned error {:?}",
+                        header,
+                        size,
+                        res.unwrap_err()
+                    );
                 }
             }
 
diff --git a/crates/core/src/http/request.rs b/crates/core/src/http/request.rs
index 507fe6f1a..ba0bb5869 100644
--- a/crates/core/src/http/request.rs
+++ b/crates/core/src/http/request.rs
@@ -25,7 +25,9 @@ use crate::http::body::ReqBody;
 use crate::http::form::{FilePart, FormData};
 use crate::http::{Mime, ParseError, Version};
 use crate::routing::PathParams;
-use crate::serde::{from_request, from_str_map, from_str_multi_map, from_str_multi_val, from_str_val};
+use crate::serde::{
+    from_request, from_str_map, from_str_multi_map, from_str_multi_val, from_str_val,
+};
 use crate::Error;
 
 static SECURE_MAX_SIZE: RwLock<usize> = RwLock::new(64 * 1024);
@@ -152,7 +154,9 @@ impl Request {
             for header in headers.get_all(http::header::COOKIE) {
                 if let Ok(header) = header.to_str() {
                     for cookie_str in header.split(';').map(|s| s.trim()) {
-                        if let Ok(cookie) = Cookie::parse_encoded(cookie_str).map(|c| c.into_owned()) {
+                        if let Ok(cookie) =
+                            Cookie::parse_encoded(cookie_str).map(|c| c.into_owned())
+                        {
                             cookie_jar.add_original(cookie);
                         }
                     }
@@ -391,7 +395,12 @@ impl Request {
     ///
     /// When `overwrite` is set to `true`, If the header is already present, the value will be replaced.
     /// When `overwrite` is set to `false`, The new header is always appended to the request, even if the header already exists.
-    pub fn add_header<N, V>(&mut self, name: N, value: V, overwrite: bool) -> crate::Result<&mut Self>
+    pub fn add_header<N, V>(
+        &mut self,
+        name: N,
+        value: V,
+        overwrite: bool,
+    ) -> crate::Result<&mut Self>
     where
         N: IntoHeaderName,
         V: TryInto<HeaderValue>,
@@ -596,7 +605,9 @@ impl Request {
     /// Get mutable queries reference.
     pub fn queries_mut(&mut self) -> &mut MultiMap<String, String> {
         let _ = self.queries();
-        self.queries.get_mut().expect("queries should be initialized")
+        self.queries
+            .get_mut()
+            .expect("queries should be initialized")
     }
 
     /// Get query value from queries.
@@ -605,7 +616,9 @@ impl Request {
     where
         T: Deserialize<'de>,
     {
-        self.queries().get_vec(key).and_then(|vs| from_str_multi_val(vs).ok())
+        self.queries()
+            .get_vec(key)
+            .and_then(|vs| from_str_multi_val(vs).ok())
     }
 
     /// Get field data from form.
@@ -667,7 +680,10 @@ impl Request {
     /// Get [`FilePart`] list reference from request.
     #[inline]
     pub async fn files<'a>(&'a mut self, key: &'a str) -> Option<&'a Vec<FilePart>> {
-        self.form_data().await.ok().and_then(|ps| ps.files.get_vec(key))
+        self.form_data()
+            .await
+            .ok()
+            .and_then(|ps| ps.files.get_vec(key))
     }
 
     /// Get [`FilePart`] list reference from request.
@@ -738,7 +754,10 @@ impl Request {
 
     /// Extract request as type `T` from request's different parts.
     #[inline]
-    pub async fn extract_with_metadata<'de, T>(&'de mut self, metadata: &'de Metadata) -> Result<T, ParseError>
+    pub async fn extract_with_metadata<'de, T>(
+        &'de mut self,
+        metadata: &'de Metadata,
+    ) -> Result<T, ParseError>
     where
         T: Deserialize<'de> + Send,
     {
@@ -804,22 +823,28 @@ impl Request {
     }
     /// Parse json body as type `T` from request with max size limit.
     #[inline]
-    pub async fn parse_json_with_max_size<'de, T>(&'de mut self, max_size: usize) -> Result<T, ParseError>
+    pub async fn parse_json_with_max_size<'de, T>(
+        &'de mut self,
+        max_size: usize,
+    ) -> Result<T, ParseError>
     where
         T: Deserialize<'de>,
     {
         let ctype = self.content_type();
         if let Some(ctype) = ctype {
             if ctype.subtype() == mime::JSON {
-                return self.payload_with_max_size(max_size).await.and_then(|payload| {
-                    // fix issue https://github.com/salvo-rs/salvo/issues/545
-                    let payload = if payload.is_empty() {
-                        "null".as_bytes()
-                    } else {
-                        payload.as_ref()
-                    };
-                    serde_json::from_slice::<T>(payload).map_err(ParseError::SerdeJson)
-                });
+                return self
+                    .payload_with_max_size(max_size)
+                    .await
+                    .and_then(|payload| {
+                        // fix issue https://github.com/salvo-rs/salvo/issues/545
+                        let payload = if payload.is_empty() {
+                            "null".as_bytes()
+                        } else {
+                            payload.as_ref()
+                        };
+                        serde_json::from_slice::<T>(payload).map_err(ParseError::SerdeJson)
+                    });
             }
         }
         Err(ParseError::InvalidContentType)
@@ -833,7 +858,8 @@ impl Request {
     {
         if let Some(ctype) = self.content_type() {
             if ctype.subtype() == mime::WWW_FORM_URLENCODED || ctype.subtype() == mime::FORM_DATA {
-                return from_str_multi_map(self.form_data().await?.fields.iter_all()).map_err(ParseError::Deserialize);
+                return from_str_multi_map(self.form_data().await?.fields.iter_all())
+                    .map_err(ParseError::Deserialize);
             }
         }
         Err(ParseError::InvalidContentType)
@@ -849,18 +875,21 @@ impl Request {
     }
 
     /// Parse json body or form body as type `T` from request with max size.
-    pub async fn parse_body_with_max_size<'de, T>(&'de mut self, max_size: usize) -> Result<T, ParseError>
+    pub async fn parse_body_with_max_size<'de, T>(
+        &'de mut self,
+        max_size: usize,
+    ) -> Result<T, ParseError>
     where
         T: Deserialize<'de>,
     {
         if let Some(ctype) = self.content_type() {
             if ctype.subtype() == mime::WWW_FORM_URLENCODED || ctype.subtype() == mime::FORM_DATA {
-                return from_str_multi_map(self.form_data().await?.fields.iter_all()).map_err(ParseError::Deserialize);
+                return from_str_multi_map(self.form_data().await?.fields.iter_all())
+                    .map_err(ParseError::Deserialize);
             } else if ctype.subtype() == mime::JSON {
-                return self
-                    .payload_with_max_size(max_size)
-                    .await
-                    .and_then(|body| serde_json::from_slice::<T>(body).map_err(ParseError::SerdeJson));
+                return self.payload_with_max_size(max_size).await.and_then(|body| {
+                    serde_json::from_slice::<T>(body).map_err(ParseError::SerdeJson)
+                });
             }
         }
         Err(ParseError::InvalidContentType)
@@ -913,14 +942,23 @@ mod tests {
             name: String,
         }
         let mut req = TestClient::get("http://127.0.0.1:5800/hello")
-            .json(&User { name: "jobs".into() })
+            .json(&User {
+                name: "jobs".into(),
+            })
             .build();
-        assert_eq!(req.parse_json::<User>().await.unwrap(), User { name: "jobs".into() });
+        assert_eq!(
+            req.parse_json::<User>().await.unwrap(),
+            User {
+                name: "jobs".into()
+            }
+        );
     }
     #[tokio::test]
     async fn test_query() {
-        let req = TestClient::get("http://127.0.0.1:5801/hello?name=rust&name=25&name=a&name=2&weapons=98&weapons=gun")
-            .build();
+        let req = TestClient::get(
+            "http://127.0.0.1:5801/hello?name=rust&name=25&name=a&name=2&weapons=98&weapons=gun",
+        )
+        .build();
         assert_eq!(req.queries().len(), 2);
         assert_eq!(req.query::<String>("name").unwrap(), "rust");
         assert_eq!(req.query::<&str>("name").unwrap(), "rust");
diff --git a/crates/core/src/http/response.rs b/crates/core/src/http/response.rs
index 03d0afc2a..e7c4ec22f 100644
--- a/crates/core/src/http/response.rs
+++ b/crates/core/src/http/response.rs
@@ -135,7 +135,12 @@ impl Response {
     ///
     /// When `overwrite` is set to `true`, If the header is already present, the value will be replaced.
     /// When `overwrite` is set to `false`, The new header is always appended to the request, even if the header already exists.
-    pub fn add_header<N, V>(&mut self, name: N, value: V, overwrite: bool) -> crate::Result<&mut Self>
+    pub fn add_header<N, V>(
+        &mut self,
+        name: N,
+        value: V,
+        overwrite: bool,
+    ) -> crate::Result<&mut Self>
     where
         N: IntoHeaderName,
         V: TryInto<HeaderValue>,
@@ -430,25 +435,33 @@ impl Response {
                 chunks.push_back(data.into());
             }
             ResBody::Hyper(_) => {
-                tracing::error!("current body's kind is `ResBody::Hyper`, it is not allowed to write bytes");
+                tracing::error!(
+                    "current body's kind is `ResBody::Hyper`, it is not allowed to write bytes"
+                );
                 return Err(Error::other(
                     "current body's kind is `ResBody::Hyper`, it is not allowed to write bytes",
                 ));
             }
             ResBody::Boxed(_) => {
-                tracing::error!("current body's kind is `ResBody::Boxed`, it is not allowed to write bytes");
+                tracing::error!(
+                    "current body's kind is `ResBody::Boxed`, it is not allowed to write bytes"
+                );
                 return Err(Error::other(
                     "current body's kind is `ResBody::Boxed`, it is not allowed to write bytes",
                 ));
             }
             ResBody::Stream(_) => {
-                tracing::error!("current body's kind is `ResBody::Stream`, it is not allowed to write bytes");
+                tracing::error!(
+                    "current body's kind is `ResBody::Stream`, it is not allowed to write bytes"
+                );
                 return Err(Error::other(
                     "current body's kind is `ResBody::Stream`, it is not allowed to write bytes",
                 ));
             }
             ResBody::Channel { .. } => {
-                tracing::error!("current body's kind is `ResBody::Channel`, it is not allowed to write bytes");
+                tracing::error!(
+                    "current body's kind is `ResBody::Channel`, it is not allowed to write bytes"
+                );
                 return Err(Error::other(
                     "current body's kind is `ResBody::Channel`, it is not allowed to write bytes",
                 ));
diff --git a/crates/core/src/routing/filters/mod.rs b/crates/core/src/routing/filters/mod.rs
index 23c3fdf50..12df81ea5 100644
--- a/crates/core/src/routing/filters/mod.rs
+++ b/crates/core/src/routing/filters/mod.rs
@@ -199,25 +199,37 @@ mod tests {
         let mut path_state = PathState::new("http://localhost/one");
         assert!(one_filter.filter(&mut req, &mut path_state));
         assert!(!two_filter.filter(&mut req, &mut path_state));
-        assert!(one_filter.or_else(has_two).filter(&mut req, &mut path_state));
+        assert!(one_filter
+            .or_else(has_two)
+            .filter(&mut req, &mut path_state));
         assert!(one_filter.or(two_filter).filter(&mut req, &mut path_state));
-        assert!(!one_filter.and_then(has_two).filter(&mut req, &mut path_state));
+        assert!(!one_filter
+            .and_then(has_two)
+            .filter(&mut req, &mut path_state));
         assert!(!one_filter.and(two_filter).filter(&mut req, &mut path_state));
 
         let mut path_state = PathState::new("http://localhost/one/two");
         assert!(one_filter.filter(&mut req, &mut path_state));
         assert!(two_filter.filter(&mut req, &mut path_state));
-        assert!(one_filter.or_else(has_two).filter(&mut req, &mut path_state));
+        assert!(one_filter
+            .or_else(has_two)
+            .filter(&mut req, &mut path_state));
         assert!(one_filter.or(two_filter).filter(&mut req, &mut path_state));
-        assert!(one_filter.and_then(has_two).filter(&mut req, &mut path_state));
+        assert!(one_filter
+            .and_then(has_two)
+            .filter(&mut req, &mut path_state));
         assert!(one_filter.and(two_filter).filter(&mut req, &mut path_state));
 
         let mut path_state = PathState::new("http://localhost/two");
         assert!(!one_filter.filter(&mut req, &mut path_state));
         assert!(two_filter.filter(&mut req, &mut path_state));
-        assert!(one_filter.or_else(has_two).filter(&mut req, &mut path_state));
+        assert!(one_filter
+            .or_else(has_two)
+            .filter(&mut req, &mut path_state));
         assert!(one_filter.or(two_filter).filter(&mut req, &mut path_state));
-        assert!(!one_filter.and_then(has_two).filter(&mut req, &mut path_state));
+        assert!(!one_filter
+            .and_then(has_two)
+            .filter(&mut req, &mut path_state));
         assert!(!one_filter.and(two_filter).filter(&mut req, &mut path_state));
     }
 }
diff --git a/crates/core/src/routing/filters/others.rs b/crates/core/src/routing/filters/others.rs
index aeb625544..370035769 100644
--- a/crates/core/src/routing/filters/others.rs
+++ b/crates/core/src/routing/filters/others.rs
@@ -41,7 +41,10 @@ pub struct SchemeFilter {
 impl SchemeFilter {
     /// Create a new `SchemeFilter`.
     pub fn new(scheme: Scheme) -> Self {
-        Self { scheme, lack: false }
+        Self {
+            scheme,
+            lack: false,
+        }
     }
     /// Set lack value and return `Self`.
     pub fn lack(mut self, lack: bool) -> Self {
@@ -52,7 +55,10 @@ impl SchemeFilter {
 impl Filter for SchemeFilter {
     #[inline]
     fn filter(&self, req: &mut Request, _state: &mut PathState) -> bool {
-        req.uri().scheme().map(|s| s == &self.scheme).unwrap_or(self.lack)
+        req.uri()
+            .scheme()
+            .map(|s| s == &self.scheme)
+            .unwrap_or(self.lack)
     }
 }
 impl fmt::Debug for SchemeFilter {
diff --git a/crates/core/src/routing/filters/path.rs b/crates/core/src/routing/filters/path.rs
index d57d0b03b..18957a32b 100644
--- a/crates/core/src/routing/filters/path.rs
+++ b/crates/core/src/routing/filters/path.rs
@@ -37,8 +37,14 @@ pub trait WispBuilder: Send + Sync {
 type WispBuilderMap = RwLock<HashMap<String, Arc<Box<dyn WispBuilder>>>>;
 static WISP_BUILDERS: LazyLock<WispBuilderMap> = LazyLock::new(|| {
     let mut map: HashMap<String, Arc<Box<dyn WispBuilder>>> = HashMap::with_capacity(8);
-    map.insert("num".into(), Arc::new(Box::new(CharsWispBuilder::new(is_num))));
-    map.insert("hex".into(), Arc::new(Box::new(CharsWispBuilder::new(is_hex))));
+    map.insert(
+        "num".into(),
+        Arc::new(Box::new(CharsWispBuilder::new(is_num))),
+    );
+    map.insert(
+        "hex".into(),
+        Arc::new(Box::new(CharsWispBuilder::new(is_hex))),
+    );
     RwLock::new(map)
 });
 
@@ -170,7 +176,10 @@ impl WispBuilder for CharsWispBuilder {
             }
             .into());
         }
-        let ps = args[0].splitn(2, "..").map(|s| s.trim()).collect::<Vec<_>>();
+        let ps = args[0]
+            .splitn(2, "..")
+            .map(|s| s.trim())
+            .collect::<Vec<_>>();
         let (min_width, max_width) = if ps.is_empty() {
             (1, None)
         } else {
@@ -289,10 +298,14 @@ pub struct CombWisp(pub Vec<WispKind>);
 impl CombWisp {
     #[inline]
     fn find_const_wisp_from(&self, index: usize) -> Option<(usize, &ConstWisp)> {
-        self.0.iter().skip(index).enumerate().find_map(|(i, wisp)| match wisp {
-            WispKind::Const(wisp) => Some((i + index, wisp)),
-            _ => None,
-        })
+        self.0
+            .iter()
+            .skip(index)
+            .enumerate()
+            .find_map(|(i, wisp)| match wisp {
+                WispKind::Const(wisp) => Some((i + index, wisp)),
+                _ => None,
+            })
     }
 }
 impl PathWisp for CombWisp {
@@ -327,7 +340,8 @@ impl PathWisp for CombWisp {
             }
             if online_all_matched {
                 state.cursor.1 = 0;
-                if let Some((next_const_index, next_const_wisp)) = self.find_const_wisp_from(index) {
+                if let Some((next_const_index, next_const_wisp)) = self.find_const_wisp_from(index)
+                {
                     if next_const_index == self.0.len() - 1 {
                         if offline.ends_with(&next_const_wisp.0) {
                             if index == next_const_index {
@@ -347,7 +361,9 @@ impl PathWisp for CombWisp {
                         } else {
                             return false;
                         }
-                    } else if let Some((new_online, new_offline)) = offline.split_once(&next_const_wisp.0) {
+                    } else if let Some((new_online, new_offline)) =
+                        offline.split_once(&next_const_wisp.0)
+                    {
                         if next_const_index == index {
                             if !new_online.is_empty() {
                                 return false;
@@ -380,7 +396,10 @@ impl PathWisp for CombWisp {
                 return false;
             }
         }
-        *(state.parts.get_mut(row).expect("path state part should be exists")) = origin_part;
+        *(state
+            .parts
+            .get_mut(row)
+            .expect("path state part should be exists")) = origin_part;
         offline.is_empty()
     }
     fn validate(&self) -> Result<(), String> {
@@ -415,7 +434,12 @@ impl PathWisp for NamedWisp {
     fn detect<'a>(&self, state: &mut PathState) -> bool {
         if self.0.starts_with('*') {
             let rest = state.all_rest().unwrap_or_default();
-            if self.0.starts_with("*?") && rest.trim_start_matches('/').trim_end_matches('/').contains('/') {
+            if self.0.starts_with("*?")
+                && rest
+                    .trim_start_matches('/')
+                    .trim_end_matches('/')
+                    .contains('/')
+            {
                 return false;
             }
             if !rest.is_empty() || !self.0.starts_with("*+") {
@@ -465,7 +489,12 @@ impl PathWisp for RegexWisp {
     fn detect<'a>(&self, state: &mut PathState) -> bool {
         if self.name.starts_with('*') {
             let rest = state.all_rest().unwrap_or_default();
-            if self.name.starts_with("*?") && rest.trim_start_matches('/').trim_end_matches('/').contains('/') {
+            if self.name.starts_with("*?")
+                && rest
+                    .trim_start_matches('/')
+                    .trim_end_matches('/')
+                    .contains('/')
+            {
                 return false;
             }
             if !rest.is_empty() || !self.name.starts_with("*+") {
@@ -667,7 +696,8 @@ impl PathParser {
         let mut wisps: Vec<WispKind> = vec![];
         while ch != '/' {
             if ch == '<' {
-                self.next(true).ok_or_else(|| "char is needed after <".to_owned())?;
+                self.next(true)
+                    .ok_or_else(|| "char is needed after <".to_owned())?;
                 let name = self.scan_ident()?;
                 if name.is_empty() {
                     return Err("name is empty string".to_owned());
@@ -685,13 +715,15 @@ impl PathParser {
                         //start to scan fn part
                         let sign = self.scan_ident()?;
                         self.skip_blanks();
-                        let lb = self.curr().ok_or_else(|| "path ended unexpectedly".to_owned())?;
+                        let lb = self
+                            .curr()
+                            .ok_or_else(|| "path ended unexpectedly".to_owned())?;
                         let args = if lb == '[' || lb == '(' {
                             let rb = if lb == '[' { ']' } else { ')' };
                             let mut args = "".to_owned();
-                            ch = self
-                                .next(true)
-                                .ok_or_else(|| "current position is out of index when scan ident".to_owned())?;
+                            ch = self.next(true).ok_or_else(|| {
+                                "current position is out of index when scan ident".to_owned()
+                            })?;
                             while ch != rb {
                                 args.push(ch);
                                 if let Some(c) = self.next(false) {
@@ -720,7 +752,9 @@ impl PathParser {
                         let builders = WISP_BUILDERS.read();
                         let builder = builders
                             .get(&sign)
-                            .ok_or_else(|| format!("WISP_BUILDERS does not contains fn part with sign {sign}"))?
+                            .ok_or_else(|| {
+                                format!("WISP_BUILDERS does not contains fn part with sign {sign}")
+                            })?
                             .clone();
 
                         wisps.push(builder.build(name, sign, args)?);
@@ -771,7 +805,10 @@ impl PathParser {
         loop {
             self.skip_slashes();
             if self.curr().map(|c| c == '/').unwrap_or(false) {
-                return Err(format!("'/' is not allowed after '/' at offset `{}`", self.offset));
+                return Err(format!(
+                    "'/' is not allowed after '/' at offset `{}`",
+                    self.offset
+                ));
             }
             let mut scaned = self.scan_wisps()?;
             if scaned.len() > 1 {
@@ -896,7 +933,10 @@ impl PathFilter {
                 panic!("{}, raw_value: {}", e, raw_value);
             }
         };
-        PathFilter { raw_value, path_wisps }
+        PathFilter {
+            raw_value,
+            path_wisps,
+        }
     }
     /// Register new path wisp builder.
     #[inline]
@@ -911,7 +951,10 @@ impl PathFilter {
     #[inline]
     pub fn register_wisp_regex(name: impl Into<String>, regex: Regex) {
         let mut builders = WISP_BUILDERS.write();
-        builders.insert(name.into(), Arc::new(Box::new(RegexWispBuilder::new(regex))));
+        builders.insert(
+            name.into(),
+            Arc::new(Box::new(RegexWispBuilder::new(regex))),
+        );
     }
     /// Detect is that path is match.
     pub fn detect(&self, state: &mut PathState) -> bool {
@@ -956,7 +999,10 @@ mod tests {
     #[test]
     fn test_parse_multi_const() {
         let segments = PathParser::new("/hello/world").parse().unwrap();
-        assert_eq!(format!("{:?}", segments), r#"[ConstWisp("hello"), ConstWisp("world")]"#);
+        assert_eq!(
+            format!("{:?}", segments),
+            r#"[ConstWisp("hello"), ConstWisp("world")]"#
+        );
     }
     #[test]
     fn test_parse_single_regex() {
@@ -992,7 +1038,9 @@ mod tests {
     }
     #[test]
     fn test_parse_single_regex_with_prefix_and_suffix() {
-        let segments = PathParser::new(r"/prefix<abc:/\d+/>suffix.png").parse().unwrap();
+        let segments = PathParser::new(r"/prefix<abc:/\d+/>suffix.png")
+            .parse()
+            .unwrap();
         assert_eq!(
             format!("{:?}", segments),
             r#"[CombWisp([ConstWisp("prefix"), RegexWisp { name: "abc", regex: Regex("\\d+") }, ConstWisp("suffix.png")])]"#
@@ -1000,7 +1048,9 @@ mod tests {
     }
     #[test]
     fn test_parse_dot_after_param() {
-        let segments = PathParser::new(r"/<pid>/show/<table_name>.bu").parse().unwrap();
+        let segments = PathParser::new(r"/<pid>/show/<table_name>.bu")
+            .parse()
+            .unwrap();
         assert_eq!(
             format!("{:?}", segments),
             r#"[NamedWisp("pid"), ConstWisp("show"), CombWisp([NamedWisp("table_name"), ConstWisp(".bu")])]"#
@@ -1008,7 +1058,9 @@ mod tests {
     }
     #[test]
     fn test_parse_multi_regex() {
-        let segments = PathParser::new(r"/first<id>/prefix<abc:/\d+/>").parse().unwrap();
+        let segments = PathParser::new(r"/first<id>/prefix<abc:/\d+/>")
+            .parse()
+            .unwrap();
         assert_eq!(
             format!("{:?}", segments),
             r#"[CombWisp([ConstWisp("first"), NamedWisp("id")]), CombWisp([ConstWisp("prefix"), RegexWisp { name: "abc", regex: Regex("\\d+") }])]"#
@@ -1016,7 +1068,9 @@ mod tests {
     }
     #[test]
     fn test_parse_multi_regex_with_prefix() {
-        let segments = PathParser::new(r"/first<id>/prefix<abc:/\d+/>").parse().unwrap();
+        let segments = PathParser::new(r"/first<id>/prefix<abc:/\d+/>")
+            .parse()
+            .unwrap();
         assert_eq!(
             format!("{:?}", segments),
             r#"[CombWisp([ConstWisp("first"), NamedWisp("id")]), CombWisp([ConstWisp("prefix"), RegexWisp { name: "abc", regex: Regex("\\d+") }])]"#
@@ -1024,7 +1078,9 @@ mod tests {
     }
     #[test]
     fn test_parse_multi_regex_with_suffix() {
-        let segments = PathParser::new(r"/first<id:/\d+/>/prefix<abc:/\d+/>").parse().unwrap();
+        let segments = PathParser::new(r"/first<id:/\d+/>/prefix<abc:/\d+/>")
+            .parse()
+            .unwrap();
         assert_eq!(
             format!("{:?}", segments),
             r#"[CombWisp([ConstWisp("first"), RegexWisp { name: "id", regex: Regex("\\d+") }]), CombWisp([ConstWisp("prefix"), RegexWisp { name: "abc", regex: Regex("\\d+") }])]"#
@@ -1032,7 +1088,9 @@ mod tests {
     }
     #[test]
     fn test_parse_multi_regex_with_prefix_and_suffix() {
-        let segments = PathParser::new(r"/first<id>/prefix<abc:/\d+/>ext").parse().unwrap();
+        let segments = PathParser::new(r"/first<id>/prefix<abc:/\d+/>ext")
+            .parse()
+            .unwrap();
         assert_eq!(
             format!("{:?}", segments),
             r#"[CombWisp([ConstWisp("first"), NamedWisp("id")]), CombWisp([ConstWisp("prefix"), RegexWisp { name: "abc", regex: Regex("\\d+") }, ConstWisp("ext")])]"#
@@ -1143,16 +1201,22 @@ mod tests {
 
     #[test]
     fn test_parse_rest2_failed() {
-        assert!(PathParser::new(r"/first<id><*ext>/<**rest>").parse().is_err());
+        assert!(PathParser::new(r"/first<id><*ext>/<**rest>")
+            .parse()
+            .is_err());
     }
 
     #[test]
     fn test_parse_rest_failed1() {
-        assert!(PathParser::new(r"/first<id>ext2/<**rest><id>").parse().is_err());
+        assert!(PathParser::new(r"/first<id>ext2/<**rest><id>")
+            .parse()
+            .is_err());
     }
     #[test]
     fn test_parse_rest_failed2() {
-        assert!(PathParser::new(r"/first<id>ext2/<**rest>wefwe").parse().is_err());
+        assert!(PathParser::new(r"/first<id>ext2/<**rest>wefwe")
+            .parse()
+            .is_err());
     }
     #[test]
     fn test_parse_many_slashes() {
diff --git a/crates/core/src/routing/mod.rs b/crates/core/src/routing/mod.rs
index cbafb092e..7c5d8382d 100644
--- a/crates/core/src/routing/mod.rs
+++ b/crates/core/src/routing/mod.rs
@@ -589,7 +589,12 @@ impl FlowCtrl {
     ///
     /// **NOTE**: If response status code is error or is redirection, all reset handlers will be skipped.
     #[inline]
-    pub async fn call_next(&mut self, req: &mut Request, depot: &mut Depot, res: &mut Response) -> bool {
+    pub async fn call_next(
+        &mut self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+    ) -> bool {
         if self.catching.is_none() {
             self.catching = Some(res.is_stamped());
         }
@@ -669,7 +674,9 @@ mod tests {
                 .unwrap()
         }
 
-        assert!(access(&service, "127.0.0.1").await.contains("404: Not Found"));
+        assert!(access(&service, "127.0.0.1")
+            .await
+            .contains("404: Not Found"));
         assert_eq!(access(&service, "localhost").await, "Hello World");
     }
 }
diff --git a/crates/core/src/routing/router.rs b/crates/core/src/routing/router.rs
index 8422b161b..eaad92da2 100644
--- a/crates/core/src/routing/router.rs
+++ b/crates/core/src/routing/router.rs
@@ -171,7 +171,10 @@ impl Router {
         H: Handler,
         F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static,
     {
-        self.hoops.push(Arc::new(WhenHoop { inner: hoop, filter }));
+        self.hoops.push(Arc::new(WhenHoop {
+            inner: hoop,
+            filter,
+        }));
         self
     }
 
@@ -403,7 +406,10 @@ mod tests {
         let router = Router::default()
             .push(
                 Router::with_path("users")
-                    .push(Router::with_path("<id>").push(Router::with_path("emails").get(fake_handler)))
+                    .push(
+                        Router::with_path("<id>")
+                            .push(Router::with_path("emails").get(fake_handler)),
+                    )
                     .push(
                         Router::with_path("<id>/articles/<aid>")
                             .get(fake_handler)
@@ -417,7 +423,11 @@ mod tests {
                             .get(fake_handler)
                             .delete(fake_handler),
                     )
-                    .push(Router::with_path("<id>").get(fake_handler).delete(fake_handler)),
+                    .push(
+                        Router::with_path("<id>")
+                            .get(fake_handler)
+                            .delete(fake_handler),
+                    ),
             );
         assert_eq!(
             format!("{:?}", router),
@@ -441,10 +451,10 @@ mod tests {
     }
     #[test]
     fn test_router_detect1() {
-        let router = Router::default().push(
-            Router::with_path("users")
-                .push(Router::with_path("<id>").push(Router::with_path("emails").get(fake_handler))),
-        );
+        let router =
+            Router::default().push(Router::with_path("users").push(
+                Router::with_path("<id>").push(Router::with_path("emails").get(fake_handler)),
+            ));
         let mut req = TestClient::get("http://local.host/users/12/emails").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
@@ -454,10 +464,9 @@ mod tests {
     fn test_router_detect2() {
         let router = Router::new()
             .push(Router::with_path("users").push(Router::with_path("<id>").get(fake_handler)))
-            .push(
-                Router::with_path("users")
-                    .push(Router::with_path("<id>").push(Router::with_path("emails").get(fake_handler))),
-            );
+            .push(Router::with_path("users").push(
+                Router::with_path("<id>").push(Router::with_path("emails").get(fake_handler)),
+            ));
         let mut req = TestClient::get("http://local.host/users/12/emails").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
@@ -467,8 +476,10 @@ mod tests {
     fn test_router_detect3() {
         let router = Router::new().push(
             Router::with_path("users").push(
-                Router::with_path(r"<id:/\d+/>")
-                    .push(Router::new().push(Router::with_path("facebook/insights/<**rest>").goal(fake_handler))),
+                Router::with_path(r"<id:/\d+/>").push(
+                    Router::new()
+                        .push(Router::with_path("facebook/insights/<**rest>").goal(fake_handler)),
+                ),
             ),
         );
         let mut req = TestClient::get("http://local.host/users/12/facebook/insights").build();
@@ -486,8 +497,10 @@ mod tests {
     fn test_router_detect4() {
         let router = Router::new().push(
             Router::with_path("users").push(
-                Router::with_path(r"<id:/\d+/>")
-                    .push(Router::new().push(Router::with_path("facebook/insights/<*+rest>").goal(fake_handler))),
+                Router::with_path(r"<id:/\d+/>").push(
+                    Router::new()
+                        .push(Router::with_path("facebook/insights/<*+rest>").goal(fake_handler)),
+                ),
             ),
         );
         let mut req = TestClient::get("http://local.host/users/12/facebook/insights").build();
@@ -503,12 +516,16 @@ mod tests {
     }
     #[test]
     fn test_router_detect5() {
-        let router =
-            Router::new().push(Router::with_path("users").push(Router::with_path(r"<id:/\d+/>").push(
-                Router::new().push(
-                    Router::with_path("facebook/insights").push(Router::with_path("<**rest>").goal(fake_handler)),
+        let router = Router::new().push(
+            Router::with_path("users").push(
+                Router::with_path(r"<id:/\d+/>").push(
+                    Router::new().push(
+                        Router::with_path("facebook/insights")
+                            .push(Router::with_path("<**rest>").goal(fake_handler)),
+                    ),
                 ),
-            )));
+            ),
+        );
         let mut req = TestClient::get("http://local.host/users/12/facebook/insights").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
@@ -522,12 +539,16 @@ mod tests {
     }
     #[test]
     fn test_router_detect6() {
-        let router =
-            Router::new().push(Router::with_path("users").push(Router::with_path(r"<id:/\d+/>").push(
-                Router::new().push(
-                    Router::with_path("facebook/insights").push(Router::new().path("<*+rest>").goal(fake_handler)),
+        let router = Router::new().push(
+            Router::with_path("users").push(
+                Router::with_path(r"<id:/\d+/>").push(
+                    Router::new().push(
+                        Router::with_path("facebook/insights")
+                            .push(Router::new().path("<*+rest>").goal(fake_handler)),
+                    ),
                 ),
-            )));
+            ),
+        );
         let mut req = TestClient::get("http://local.host/users/12/facebook/insights").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
@@ -540,25 +561,32 @@ mod tests {
     }
     #[test]
     fn test_router_detect_utf8() {
-        let router =
-            Router::new().push(Router::with_path("用户").push(Router::with_path(r"<id:/\d+/>").push(
-                Router::new().push(
-                    Router::with_path("facebook/insights").push(Router::with_path("<*+rest>").goal(fake_handler)),
+        let router = Router::new().push(
+            Router::with_path("用户").push(
+                Router::with_path(r"<id:/\d+/>").push(
+                    Router::new().push(
+                        Router::with_path("facebook/insights")
+                            .push(Router::with_path("<*+rest>").goal(fake_handler)),
+                    ),
                 ),
-            )));
-        let mut req = TestClient::get("http://local.host/%E7%94%A8%E6%88%B7/12/facebook/insights").build();
+            ),
+        );
+        let mut req =
+            TestClient::get("http://local.host/%E7%94%A8%E6%88%B7/12/facebook/insights").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
         assert!(matched.is_none());
 
-        let mut req = TestClient::get("http://local.host/%E7%94%A8%E6%88%B7/12/facebook/insights/23").build();
+        let mut req =
+            TestClient::get("http://local.host/%E7%94%A8%E6%88%B7/12/facebook/insights/23").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
         assert!(matched.is_some());
     }
     #[test]
     fn test_router_detect9() {
-        let router = Router::new().push(Router::with_path("users/<sub:/(images|css)/>/<filename>").goal(fake_handler));
+        let router = Router::new()
+            .push(Router::with_path("users/<sub:/(images|css)/>/<filename>").goal(fake_handler));
         let mut req = TestClient::get("http://local.host/users/12/m.jpg").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
@@ -571,7 +599,8 @@ mod tests {
     }
     #[test]
     fn test_router_detect10() {
-        let router = Router::new().push(Router::with_path(r"users/<*sub:/(images|css)/.+/>").goal(fake_handler));
+        let router = Router::new()
+            .push(Router::with_path(r"users/<*sub:/(images|css)/.+/>").goal(fake_handler));
         let mut req = TestClient::get("http://local.host/users/12/m.jpg").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
@@ -584,8 +613,9 @@ mod tests {
     }
     #[test]
     fn test_router_detect11() {
-        let router =
-            Router::new().push(Router::with_path(r"avatars/<width:/\d+/>x<height:/\d+/>.<ext>").goal(fake_handler));
+        let router = Router::new().push(
+            Router::with_path(r"avatars/<width:/\d+/>x<height:/\d+/>.<ext>").goal(fake_handler),
+        );
         let mut req = TestClient::get("http://local.host/avatars/321x641f.webp").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
@@ -598,9 +628,12 @@ mod tests {
     }
     #[test]
     fn test_router_detect12() {
-        let router = Router::new().push(Router::with_path("/.well-known/acme-challenge/<token>").goal(fake_handler));
+        let router = Router::new()
+            .push(Router::with_path("/.well-known/acme-challenge/<token>").goal(fake_handler));
 
-        let mut req = TestClient::get("http://local.host/.well-known/acme-challenge/q1XXrxIx79uXNl3I").build();
+        let mut req =
+            TestClient::get("http://local.host/.well-known/acme-challenge/q1XXrxIx79uXNl3I")
+                .build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
         assert!(matched.is_some());
@@ -611,11 +644,13 @@ mod tests {
         let router = Router::new()
             .path("user/<id:/[0-9a-z]{8}(-[0-9a-z]{4}){3}-[0-9a-z]{12}/>")
             .get(fake_handler);
-        let mut req = TestClient::get("http://local.host/user/726d694c-7af0-4bb0-9d22-706f7e38641e").build();
+        let mut req =
+            TestClient::get("http://local.host/user/726d694c-7af0-4bb0-9d22-706f7e38641e").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
         assert!(matched.is_some());
-        let mut req = TestClient::get("http://local.host/user/726d694c-7af0-4bb0-9d22-706f7e386e").build();
+        let mut req =
+            TestClient::get("http://local.host/user/726d694c-7af0-4bb0-9d22-706f7e386e").build();
         let mut path_state = PathState::new(req.uri().path());
         let matched = router.detect(&mut req, &mut path_state);
         assert!(matched.is_none());
diff --git a/crates/core/src/serde/mod.rs b/crates/core/src/serde/mod.rs
index ab5c1bf34..d1b89b4d7 100644
--- a/crates/core/src/serde/mod.rs
+++ b/crates/core/src/serde/mod.rs
@@ -3,7 +3,8 @@ use std::hash::Hash;
 
 pub use serde::de::value::{Error as ValError, MapDeserializer, SeqDeserializer};
 use serde::de::{
-    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error as DeError, IntoDeserializer, VariantAccess, Visitor,
+    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error as DeError, IntoDeserializer,
+    VariantAccess, Visitor,
 };
 use serde::forward_to_deserialize_any;
 
@@ -18,7 +19,9 @@ where
     K: Into<Cow<'de, str>>,
     V: Into<Cow<'de, str>>,
 {
-    let iter = input.into_iter().map(|(k, v)| (CowValue(k.into()), CowValue(v.into())));
+    let iter = input
+        .into_iter()
+        .map(|(k, v)| (CowValue(k.into()), CowValue(v.into())));
     T::deserialize(MapDeserializer::new(iter))
 }
 
@@ -31,9 +34,12 @@ where
     C: IntoIterator<Item = V> + 'de,
     V: Into<Cow<'de, str>> + std::cmp::Eq + 'de,
 {
-    let iter = input
-        .into_iter()
-        .map(|(k, v)| (CowValue(k.into()), VecValue(v.into_iter().map(|v| CowValue(v.into())))));
+    let iter = input.into_iter().map(|(k, v)| {
+        (
+            CowValue(k.into()),
+            VecValue(v.into_iter().map(|v| CowValue(v.into()))),
+        )
+    });
     T::deserialize(MapDeserializer::new(iter))
 }
 
@@ -133,7 +139,11 @@ impl<'de> VariantAccess<'de> for UnitOnlyVariantAccess {
     }
 
     #[inline]
-    fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value, Self::Error>
+    fn struct_variant<V>(
+        self,
+        _fields: &'static [&'static str],
+        _visitor: V,
+    ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
@@ -187,7 +197,11 @@ impl<'de> Deserializer<'de> for CowValue<'de> {
     }
 
     #[inline]
-    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_newtype_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
@@ -283,7 +297,11 @@ where
     }
 
     #[inline]
-    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_newtype_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
@@ -291,7 +309,12 @@ where
     }
 
     #[inline]
-    fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_tuple_struct<V>(
+        self,
+        _name: &'static str,
+        _len: usize,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
diff --git a/crates/core/src/serde/request.rs b/crates/core/src/serde/request.rs
index ced0c2683..feb4e2764 100644
--- a/crates/core/src/serde/request.rs
+++ b/crates/core/src/serde/request.rs
@@ -17,7 +17,10 @@ use crate::Request;
 
 use super::{CowValue, VecValue};
 
-pub async fn from_request<'de, T>(req: &'de mut Request, metadata: &'de Metadata) -> Result<T, ParseError>
+pub async fn from_request<'de, T>(
+    req: &'de mut Request,
+    metadata: &'de Metadata,
+) -> Result<T, ParseError>
 where
     T: Deserialize<'de>,
 {
@@ -77,7 +80,10 @@ pub(crate) struct RequestDeserializer<'de> {
 
 impl<'de> RequestDeserializer<'de> {
     /// Construct a new `RequestDeserializer<I, E>`.
-    pub(crate) fn new(request: &'de Request, metadata: &'de Metadata) -> Result<RequestDeserializer<'de>, ParseError> {
+    pub(crate) fn new(
+        request: &'de Request,
+        metadata: &'de Metadata,
+    ) -> Result<RequestDeserializer<'de>, ParseError> {
         let mut payload = None;
 
         if metadata.has_body_required() {
@@ -90,7 +96,9 @@ impl<'de> RequestDeserializer<'de> {
                         if let Some(data) = request.payload.get() {
                             if !data.is_empty() {
                                 // https://github.com/serde-rs/json/issues/903
-                                payload = match serde_json::from_slice::<HashMap<&str, &RawValue>>(data) {
+                                payload = match serde_json::from_slice::<HashMap<&str, &RawValue>>(
+                                    data,
+                                ) {
                                     Ok(map) => Some(Payload::JsonMap(map)),
                                     Err(e) => {
                                         tracing::warn!(error = ?e, "`RequestDeserializer` serde parse json payload failed");
@@ -247,7 +255,8 @@ impl<'de> RequestDeserializer<'de> {
                         }
                     }
                     if let Some(value) = value {
-                        self.field_vec_value = Some(value.iter().map(|v| CowValue(v.into())).collect());
+                        self.field_vec_value =
+                            Some(value.iter().map(|v| CowValue(v.into())).collect());
                         self.field_source = Some(source);
                         return true;
                     }
@@ -356,7 +365,9 @@ impl<'de> RequestDeserializer<'de> {
                                     }
                                 }
                                 if let Some(value) = value {
-                                    self.field_vec_value = Some(value.iter().map(|v| CowValue(Cow::from(v))).collect());
+                                    self.field_vec_value = Some(
+                                        value.iter().map(|v| CowValue(Cow::from(v))).collect(),
+                                    );
                                     self.field_source = Some(source);
                                     return true;
                                 }
@@ -443,7 +454,11 @@ impl<'de> de::MapAccess<'de> for RequestDeserializer<'de> {
     }
 
     #[inline]
-    fn next_entry_seed<TK, TV>(&mut self, kseed: TK, vseed: TV) -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
+    fn next_entry_seed<TK, TV>(
+        &mut self,
+        kseed: TK,
+        vseed: TV,
+    ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
     where
         TK: de::DeserializeSeed<'de>,
         TV: de::DeserializeSeed<'de>,
@@ -699,7 +714,10 @@ mod tests {
             data,
             RequestData {
                 p2: "921",
-                user: User { name: "chris", age: 20 }
+                user: User {
+                    name: "chris",
+                    age: 20
+                }
             }
         );
     }
@@ -712,8 +730,10 @@ mod tests {
             #[salvo(extract(rename = "currAge"))]
             curr_age: usize,
         }
-        let mut req =
-            TestClient::get("http://127.0.0.1:5800/test/1234/param2v?full-name=chris+young&currAge=20").build();
+        let mut req = TestClient::get(
+            "http://127.0.0.1:5800/test/1234/param2v?full-name=chris+young&currAge=20",
+        )
+        .build();
         let data: RequestData = req.extract().await.unwrap();
         assert_eq!(
             data,
@@ -733,8 +753,10 @@ mod tests {
             #[salvo(extract(rename = "currAge"))]
             curr_age: usize,
         }
-        let mut req =
-            TestClient::get("http://127.0.0.1:5800/test/1234/param2v?full-name=chris+young&currAge=20").build();
+        let mut req = TestClient::get(
+            "http://127.0.0.1:5800/test/1234/param2v?full-name=chris+young&currAge=20",
+        )
+        .build();
         let data: RequestData = req.extract().await.unwrap();
         assert_eq!(
             data,
@@ -754,8 +776,10 @@ mod tests {
             #[salvo(extract(rename = "currAge"))]
             curr_age: usize,
         }
-        let mut req =
-            TestClient::get("http://127.0.0.1:5800/test/1234/param2v?full-name=chris+young&currAge=20").build();
+        let mut req = TestClient::get(
+            "http://127.0.0.1:5800/test/1234/param2v?full-name=chris+young&currAge=20",
+        )
+        .build();
         let data: RequestData = req.extract().await.unwrap();
         assert_eq!(
             data,
diff --git a/crates/core/src/service.rs b/crates/core/src/service.rs
index f21dc1e63..78e6d6139 100644
--- a/crates/core/src/service.rs
+++ b/crates/core/src/service.rs
@@ -95,7 +95,10 @@ impl Service {
         H: Handler,
         F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static,
     {
-        self.hoops.push(Arc::new(WhenHoop { inner: hoop, filter }));
+        self.hoops.push(Arc::new(WhenHoop {
+            inner: hoop,
+            filter,
+        }));
         self
     }
 
@@ -257,7 +260,10 @@ impl HyperHandler {
                     "http response content type header not set"
                 );
             }
-            if Method::HEAD != *req.method() && (res.body.is_none() || res.body.is_error()) && has_error {
+            if Method::HEAD != *req.method()
+                && (res.body.is_none() || res.body.is_error())
+                && has_error
+            {
                 if let Some(catcher) = catcher {
                     catcher.catch(&mut req, &mut depot, &mut res).await;
                 } else {
@@ -272,22 +278,23 @@ impl HyperHandler {
             {
                 use bytes::Bytes;
                 use parking_lot::Mutex;
-                if let Some(session) = req
-                    .extensions
-                    .remove::<crate::proto::WebTransportSession<salvo_http3::http3_quinn::Connection, Bytes>>()
+                if let Some(session) =
+                    req.extensions.remove::<crate::proto::WebTransportSession<
+                        salvo_http3::http3_quinn::Connection,
+                        Bytes,
+                    >>()
                 {
                     res.extensions.insert(Arc::new(session));
                 }
-                if let Some(conn) = req
-                    .extensions
-                    .remove::<Mutex<salvo_http3::server::Connection<salvo_http3::http3_quinn::Connection, Bytes>>>()
-                {
+                if let Some(conn) = req.extensions.remove::<Mutex<
+                    salvo_http3::server::Connection<salvo_http3::http3_quinn::Connection, Bytes>,
+                >>() {
                     res.extensions.insert(Arc::new(conn));
                 }
-                if let Some(stream) = req
-                    .extensions
-                    .remove::<salvo_http3::server::RequestStream<salvo_http3::http3_quinn::BidiStream<Bytes>, Bytes>>()
-                {
+                if let Some(stream) = req.extensions.remove::<salvo_http3::server::RequestStream<
+                    salvo_http3::http3_quinn::BidiStream<Bytes>,
+                    Bytes,
+                >>() {
                     res.extensions.insert(Arc::new(stream));
                 }
             }
@@ -310,7 +317,11 @@ where
         #[cfg(not(feature = "fix-http1-request-uri"))] req: HyperRequest<B>,
         #[cfg(feature = "fix-http1-request-uri")] mut req: HyperRequest<B>,
     ) -> Self::Future {
-        let scheme = req.uri().scheme().cloned().unwrap_or_else(|| self.http_scheme.clone());
+        let scheme = req
+            .uri()
+            .scheme()
+            .cloned()
+            .unwrap_or_else(|| self.http_scheme.clone());
         // https://github.com/hyperium/hyper/issues/1310
         #[cfg(feature = "fix-http1-request-uri")]
         if req.uri().scheme().is_none() {
@@ -343,7 +354,12 @@ mod tests {
     #[tokio::test]
     async fn test_service() {
         #[handler]
-        async fn before1(req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+        async fn before1(
+            req: &mut Request,
+            depot: &mut Depot,
+            res: &mut Response,
+            ctrl: &mut FlowCtrl,
+        ) {
             res.render(Text::Plain("before1"));
             if req.query::<String>("b").unwrap_or_default() == "1" {
                 ctrl.skip_rest();
@@ -352,7 +368,12 @@ mod tests {
             }
         }
         #[handler]
-        async fn before2(req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+        async fn before2(
+            req: &mut Request,
+            depot: &mut Depot,
+            res: &mut Response,
+            ctrl: &mut FlowCtrl,
+        ) {
             res.render(Text::Plain("before2"));
             if req.query::<String>("b").unwrap_or_default() == "2" {
                 ctrl.skip_rest();
@@ -361,7 +382,12 @@ mod tests {
             }
         }
         #[handler]
-        async fn before3(req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+        async fn before3(
+            req: &mut Request,
+            depot: &mut Depot,
+            res: &mut Response,
+            ctrl: &mut FlowCtrl,
+        ) {
             res.render(Text::Plain("before3"));
             if req.query::<String>("b").unwrap_or_default() == "3" {
                 ctrl.skip_rest();
diff --git a/crates/core/src/writing/json.rs b/crates/core/src/writing/json.rs
index 51e4690c8..df989698c 100644
--- a/crates/core/src/writing/json.rs
+++ b/crates/core/src/writing/json.rs
@@ -63,11 +63,15 @@ mod tests {
         }
         #[handler]
         async fn test() -> Json<User> {
-            Json(User { name: "jobs".into() })
+            Json(User {
+                name: "jobs".into(),
+            })
         }
 
         let router = Router::new().push(Router::with_path("test").get(test));
-        let mut res = TestClient::get("http://127.0.0.1:5800/test").send(router).await;
+        let mut res = TestClient::get("http://127.0.0.1:5800/test")
+            .send(router)
+            .await;
         assert_eq!(res.take_string().await.unwrap(), r#"{"name":"jobs"}"#);
         assert_eq!(
             res.headers().get("content-type").unwrap(),
diff --git a/crates/core/src/writing/mod.rs b/crates/core/src/writing/mod.rs
index 699ed001b..86956fb4a 100644
--- a/crates/core/src/writing/mod.rs
+++ b/crates/core/src/writing/mod.rs
@@ -97,24 +97,30 @@ impl Scribe for StatusCode {
 impl Scribe for &'static str {
     #[inline]
     fn render(self, res: &mut Response) {
-        res.headers_mut()
-            .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain; charset=utf-8"));
+        res.headers_mut().insert(
+            CONTENT_TYPE,
+            HeaderValue::from_static("text/plain; charset=utf-8"),
+        );
         res.write_body(self).ok();
     }
 }
 impl<'a> Scribe for &'a String {
     #[inline]
     fn render(self, res: &mut Response) {
-        res.headers_mut()
-            .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain; charset=utf-8"));
+        res.headers_mut().insert(
+            CONTENT_TYPE,
+            HeaderValue::from_static("text/plain; charset=utf-8"),
+        );
         res.write_body(self.as_bytes().to_vec()).ok();
     }
 }
 impl Scribe for String {
     #[inline]
     fn render(self, res: &mut Response) {
-        res.headers_mut()
-            .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain; charset=utf-8"));
+        res.headers_mut().insert(
+            CONTENT_TYPE,
+            HeaderValue::from_static("text/plain; charset=utf-8"),
+        );
         res.write_body(self).ok();
     }
 }
@@ -158,9 +164,14 @@ mod tests {
 
         let router = Router::new().push(Router::with_path("test").get(test));
 
-        let mut res = TestClient::get("http://127.0.0.1:5800/test").send(router).await;
+        let mut res = TestClient::get("http://127.0.0.1:5800/test")
+            .send(router)
+            .await;
         assert_eq!(res.take_string().await.unwrap(), "hello");
-        assert_eq!(res.headers().get("content-type").unwrap(), "text/plain; charset=utf-8");
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/plain; charset=utf-8"
+        );
     }
 
     #[tokio::test]
@@ -171,8 +182,13 @@ mod tests {
         }
 
         let router = Router::new().push(Router::with_path("test").get(test));
-        let mut res = TestClient::get("http://127.0.0.1:5800/test").send(router).await;
+        let mut res = TestClient::get("http://127.0.0.1:5800/test")
+            .send(router)
+            .await;
         assert_eq!(res.take_string().await.unwrap(), "hello");
-        assert_eq!(res.headers().get("content-type").unwrap(), "text/plain; charset=utf-8");
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/plain; charset=utf-8"
+        );
     }
 }
diff --git a/crates/core/src/writing/redirect.rs b/crates/core/src/writing/redirect.rs
index 65f4b267c..54741fe4a 100644
--- a/crates/core/src/writing/redirect.rs
+++ b/crates/core/src/writing/redirect.rs
@@ -78,7 +78,10 @@ impl Redirect {
     }
 
     /// Create a new [`Redirect`] that uses a status code.
-    pub fn with_status_code(status_code: StatusCode, uri: impl TryInto<Uri>) -> Result<Self, Error> {
+    pub fn with_status_code(
+        status_code: StatusCode,
+        uri: impl TryInto<Uri>,
+    ) -> Result<Self, Error> {
         if !status_code.is_redirection() {
             return Err(Error::other("not a redirection status code"));
         }
@@ -89,7 +92,8 @@ impl Redirect {
                 .try_into()
                 .map_err(|_| Error::other("It isn't a valid URI"))
                 .and_then(|uri| {
-                    HeaderValue::try_from(uri.to_string()).map_err(|_| Error::other("URI isn't a valid header value"))
+                    HeaderValue::try_from(uri.to_string())
+                        .map_err(|_| Error::other("URI isn't a valid header value"))
                 })?,
         })
     }
@@ -98,7 +102,10 @@ impl Redirect {
 impl Scribe for Redirect {
     #[inline]
     fn render(self, res: &mut Response) {
-        let Self { status_code, location } = self;
+        let Self {
+            status_code,
+            location,
+        } = self;
         res.status_code(status_code);
         res.headers_mut().insert(LOCATION, location);
     }
diff --git a/crates/core/src/writing/seek.rs b/crates/core/src/writing/seek.rs
index e8329eda1..8c8324be5 100644
--- a/crates/core/src/writing/seek.rs
+++ b/crates/core/src/writing/seek.rs
@@ -64,9 +64,10 @@ where
         // check preconditions
         let precondition_failed = if !any_match(self.etag.as_ref(), req_headers) {
             true
-        } else if let (Some(last_modified), Some(since)) =
-            (&self.last_modified, req_headers.typed_get::<IfUnmodifiedSince>())
-        {
+        } else if let (Some(last_modified), Some(since)) = (
+            &self.last_modified,
+            req_headers.typed_get::<IfUnmodifiedSince>(),
+        ) {
             !since.precondition_passes(*last_modified)
         } else {
             false
@@ -77,9 +78,10 @@ where
             true
         } else if req_headers.contains_key(IF_NONE_MATCH) {
             false
-        } else if let (Some(last_modified), Some(since)) =
-            (&self.last_modified, req_headers.typed_get::<IfModifiedSince>())
-        {
+        } else if let (Some(last_modified), Some(since)) = (
+            &self.last_modified,
+            req_headers.typed_get::<IfModifiedSince>(),
+        ) {
             !since.is_modified(*last_modified)
         } else {
             false
@@ -103,7 +105,8 @@ where
                     length = range[0].length;
                     offset = range[0].start;
                 } else {
-                    res.headers_mut().typed_insert(ContentRange::unsatisfied_bytes(length));
+                    res.headers_mut()
+                        .typed_insert(ContentRange::unsatisfied_bytes(length));
                     res.status_code(StatusCode::RANGE_NOT_SATISFIABLE);
                     return;
                 };
diff --git a/crates/core/src/writing/text.rs b/crates/core/src/writing/text.rs
index 8f9f00da8..553fc38bc 100644
--- a/crates/core/src/writing/text.rs
+++ b/crates/core/src/writing/text.rs
@@ -44,16 +44,40 @@ where
 {
     fn set_header(self, res: &mut Response) -> C {
         let (ctype, content) = match self {
-            Self::Plain(content) => (HeaderValue::from_static("text/plain; charset=utf-8"), content),
-            Self::Json(content) => (HeaderValue::from_static("application/json; charset=utf-8"), content),
-            Self::Xml(content) => (HeaderValue::from_static("application/xml; charset=utf-8"), content),
-            Self::Html(content) => (HeaderValue::from_static("text/html; charset=utf-8"), content),
-            Self::Js(content) => (HeaderValue::from_static("text/javascript; charset=utf-8"), content),
+            Self::Plain(content) => (
+                HeaderValue::from_static("text/plain; charset=utf-8"),
+                content,
+            ),
+            Self::Json(content) => (
+                HeaderValue::from_static("application/json; charset=utf-8"),
+                content,
+            ),
+            Self::Xml(content) => (
+                HeaderValue::from_static("application/xml; charset=utf-8"),
+                content,
+            ),
+            Self::Html(content) => (
+                HeaderValue::from_static("text/html; charset=utf-8"),
+                content,
+            ),
+            Self::Js(content) => (
+                HeaderValue::from_static("text/javascript; charset=utf-8"),
+                content,
+            ),
             Self::Css(content) => (HeaderValue::from_static("text/css; charset=utf-8"), content),
             Self::Csv(content) => (HeaderValue::from_static("text/csv; charset=utf-8"), content),
-            Self::Atom(content) => (HeaderValue::from_static("application/atom+xml; charset=utf-8"), content),
-            Self::Rss(content) => (HeaderValue::from_static("application/rss+xml; charset=utf-8"), content),
-            Self::Rdf(content) => (HeaderValue::from_static("application/rdf+xml; charset=utf-8"), content),
+            Self::Atom(content) => (
+                HeaderValue::from_static("application/atom+xml; charset=utf-8"),
+                content,
+            ),
+            Self::Rss(content) => (
+                HeaderValue::from_static("application/rss+xml; charset=utf-8"),
+                content,
+            ),
+            Self::Rdf(content) => (
+                HeaderValue::from_static("application/rdf+xml; charset=utf-8"),
+                content,
+            ),
         };
         res.headers_mut().insert(CONTENT_TYPE, ctype);
         content
@@ -97,9 +121,14 @@ mod tests {
 
         let router = Router::new().push(Router::with_path("test").get(test));
 
-        let mut res = TestClient::get("http://127.0.0.1:5800/test").send(router).await;
+        let mut res = TestClient::get("http://127.0.0.1:5800/test")
+            .send(router)
+            .await;
         assert_eq!(res.take_string().await.unwrap(), "hello");
-        assert_eq!(res.headers().get("content-type").unwrap(), "text/plain; charset=utf-8");
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/plain; charset=utf-8"
+        );
     }
 
     #[tokio::test]
@@ -110,9 +139,14 @@ mod tests {
         }
 
         let router = Router::new().push(Router::with_path("test").get(test));
-        let mut res = TestClient::get("http://127.0.0.1:5800/test").send(router).await;
+        let mut res = TestClient::get("http://127.0.0.1:5800/test")
+            .send(router)
+            .await;
         assert_eq!(res.take_string().await.unwrap(), "hello");
-        assert_eq!(res.headers().get("content-type").unwrap(), "text/plain; charset=utf-8");
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/plain; charset=utf-8"
+        );
     }
 
     #[tokio::test]
@@ -124,9 +158,14 @@ mod tests {
 
         let router = Router::new().push(Router::with_path("test").get(test));
 
-        let mut res = TestClient::get("http://127.0.0.1:5800/test").send(router).await;
+        let mut res = TestClient::get("http://127.0.0.1:5800/test")
+            .send(router)
+            .await;
         assert_eq!(res.take_string().await.unwrap(), "hello");
-        assert_eq!(res.headers().get("content-type").unwrap(), "text/plain; charset=utf-8");
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/plain; charset=utf-8"
+        );
     }
 
     #[tokio::test]
@@ -137,7 +176,9 @@ mod tests {
         }
 
         let router = Router::new().push(Router::with_path("test").get(test));
-        let mut res = TestClient::get("http://127.0.0.1:5800/test").send(router).await;
+        let mut res = TestClient::get("http://127.0.0.1:5800/test")
+            .send(router)
+            .await;
         assert_eq!(res.take_string().await.unwrap(), r#"{"hello": "world"}"#);
         assert_eq!(
             res.headers().get("content-type").unwrap(),
@@ -153,8 +194,16 @@ mod tests {
         }
 
         let router = Router::new().push(Router::with_path("test").get(test));
-        let mut res = TestClient::get("http://127.0.0.1:5800/test").send(router).await;
-        assert_eq!(res.take_string().await.unwrap(), "<html><body>hello</body></html>");
-        assert_eq!(res.headers().get("content-type").unwrap(), "text/html; charset=utf-8");
+        let mut res = TestClient::get("http://127.0.0.1:5800/test")
+            .send(router)
+            .await;
+        assert_eq!(
+            res.take_string().await.unwrap(),
+            "<html><body>hello</body></html>"
+        );
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/html; charset=utf-8"
+        );
     }
 }
diff --git a/crates/cors/src/allow_credentials.rs b/crates/cors/src/allow_credentials.rs
index 53047b999..e72e21fbb 100644
--- a/crates/cors/src/allow_credentials.rs
+++ b/crates/cors/src/allow_credentials.rs
@@ -13,7 +13,8 @@ use salvo_core::{Depot, Request};
 #[must_use]
 pub struct AllowCredentials(AllowCredentialsInner);
 
-type JudgeFn = Arc<dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> bool + Send + Sync + 'static>;
+type JudgeFn =
+    Arc<dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> bool + Send + Sync + 'static>;
 impl AllowCredentials {
     /// Allow credentials for all requests
     ///
diff --git a/crates/cors/src/allow_headers.rs b/crates/cors/src/allow_headers.rs
index 4cf81ab45..38527dbfc 100644
--- a/crates/cors/src/allow_headers.rs
+++ b/crates/cors/src/allow_headers.rs
@@ -16,7 +16,9 @@ use salvo_core::{Depot, Request};
 #[must_use]
 pub struct AllowHeaders(AllowHeadersInner);
 
-type JudgeFn = Arc<dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> HeaderValue + Send + Sync + 'static>;
+type JudgeFn = Arc<
+    dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> HeaderValue + Send + Sync + 'static,
+>;
 impl AllowHeaders {
     /// Allow any headers by sending a wildcard (`*`)
     ///
@@ -81,7 +83,10 @@ impl AllowHeaders {
             AllowHeadersInner::None => return None,
             AllowHeadersInner::Exact(v) => v.clone(),
             AllowHeadersInner::Judge(f) => f(origin?, req, depot),
-            AllowHeadersInner::MirrorRequest => req.headers().get(header::ACCESS_CONTROL_REQUEST_HEADERS)?.clone(),
+            AllowHeadersInner::MirrorRequest => req
+                .headers()
+                .get(header::ACCESS_CONTROL_REQUEST_HEADERS)?
+                .clone(),
         };
 
         Some((header::ACCESS_CONTROL_ALLOW_HEADERS, allow_headers))
diff --git a/crates/cors/src/allow_methods.rs b/crates/cors/src/allow_methods.rs
index 4e3442d92..54a796ec6 100644
--- a/crates/cors/src/allow_methods.rs
+++ b/crates/cors/src/allow_methods.rs
@@ -17,7 +17,9 @@ use super::{separated_by_commas, Any, WILDCARD};
 #[must_use]
 pub struct AllowMethods(AllowMethodsInner);
 
-type JudgeFn = Arc<dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> HeaderValue + Send + Sync + 'static>;
+type JudgeFn = Arc<
+    dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> HeaderValue + Send + Sync + 'static,
+>;
 impl AllowMethods {
     /// Allow any method by sending a wildcard (`*`)
     ///
@@ -93,7 +95,10 @@ impl AllowMethods {
             AllowMethodsInner::None => return None,
             AllowMethodsInner::Exact(v) => v.clone(),
             AllowMethodsInner::Judge(f) => f(origin?, req, depot),
-            AllowMethodsInner::MirrorRequest => req.headers().get(header::ACCESS_CONTROL_REQUEST_METHOD)?.clone(),
+            AllowMethodsInner::MirrorRequest => req
+                .headers()
+                .get(header::ACCESS_CONTROL_REQUEST_METHOD)?
+                .clone(),
         };
 
         Some((header::ACCESS_CONTROL_ALLOW_METHODS, allow_methods))
diff --git a/crates/cors/src/allow_origin.rs b/crates/cors/src/allow_origin.rs
index 396c7522a..64038d62a 100644
--- a/crates/cors/src/allow_origin.rs
+++ b/crates/cors/src/allow_origin.rs
@@ -15,7 +15,8 @@ use super::{Any, WILDCARD};
 #[must_use]
 pub struct AllowOrigin(OriginInner);
 
-type JudgeFn = Arc<dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> bool + Send + Sync + 'static>;
+type JudgeFn =
+    Arc<dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> bool + Send + Sync + 'static>;
 impl AllowOrigin {
     /// Allow any origin by sending a wildcard (`*`)
     ///
diff --git a/crates/cors/src/expose_headers.rs b/crates/cors/src/expose_headers.rs
index cfa1a34d5..701eb3a96 100644
--- a/crates/cors/src/expose_headers.rs
+++ b/crates/cors/src/expose_headers.rs
@@ -17,7 +17,9 @@ use super::{separated_by_commas, Any, WILDCARD};
 #[must_use]
 pub struct ExposeHeaders(ExposeHeadersInner);
 
-type JudgeFn = Arc<dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> HeaderValue + Send + Sync + 'static>;
+type JudgeFn = Arc<
+    dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> HeaderValue + Send + Sync + 'static,
+>;
 impl ExposeHeaders {
     /// Expose any / all headers by sending a wildcard (`*`)
     ///
diff --git a/crates/cors/src/lib.rs b/crates/cors/src/lib.rs
index d5d68dedd..71922e0ef 100644
--- a/crates/cors/src/lib.rs
+++ b/crates/cors/src/lib.rs
@@ -268,7 +268,13 @@ pub struct CorsHandler(Cors);
 
 #[async_trait]
 impl Handler for CorsHandler {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         let origin = req.headers().get(&header::ORIGIN);
 
         let mut headers = HeaderMap::new();
@@ -370,7 +376,9 @@ mod tests {
         assert!(headers.get(ACCESS_CONTROL_ALLOW_METHODS).is_some());
         assert!(headers.get(ACCESS_CONTROL_ALLOW_HEADERS).is_some());
 
-        let res = TestClient::options("https://google.com").send(&service).await;
+        let res = TestClient::options("https://google.com")
+            .send(&service)
+            .await;
         let headers = res.headers();
         assert!(
             headers.get(ACCESS_CONTROL_ALLOW_METHODS).is_none(),
diff --git a/crates/cors/src/max_age.rs b/crates/cors/src/max_age.rs
index 8584c8386..4aa90bc24 100644
--- a/crates/cors/src/max_age.rs
+++ b/crates/cors/src/max_age.rs
@@ -12,7 +12,9 @@ use salvo_core::{Depot, Request};
 #[must_use]
 pub struct MaxAge(MaxAgeInner);
 
-type JudgeFn = Arc<dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> HeaderValue + Send + Sync + 'static>;
+type JudgeFn = Arc<
+    dyn for<'a> Fn(&'a HeaderValue, &'a Request, &'a Depot) -> HeaderValue + Send + Sync + 'static,
+>;
 
 impl MaxAge {
     /// Set a static max-age value
diff --git a/crates/csrf/src/lib.rs b/crates/csrf/src/lib.rs
index 7425cf4d3..7d02d7bf7 100644
--- a/crates/csrf/src/lib.rs
+++ b/crates/csrf/src/lib.rs
@@ -260,7 +260,13 @@ impl<C: CsrfCipher, S: CsrfStore> Csrf<C, S> {
 
 #[async_trait]
 impl<C: CsrfCipher, S: CsrfStore> Handler for Csrf<C, S> {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         match self.store.load(req, depot, &self.cipher).await {
             Some((token, proof)) => {
                 depot.insert(CSRF_TOKEN_KEY, token);
@@ -269,7 +275,9 @@ impl<C: CsrfCipher, S: CsrfStore> Handler for Csrf<C, S> {
                     if let Some(token) = &self.find_token(req).await {
                         tracing::debug!("csrf token: {token}");
                         if !self.cipher.verify(token, &proof) {
-                            tracing::debug!("rejecting request due to invalid or expired CSRF token");
+                            tracing::debug!(
+                                "rejecting request due to invalid or expired CSRF token"
+                            );
                             res.status_code(StatusCode::FORBIDDEN);
                             ctrl.skip_rest();
                             return;
@@ -357,13 +365,17 @@ mod tests {
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let csrf_token = res.take_string().await.unwrap();
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
 
         let mut res = TestClient::post("http://127.0.0.1:5801")
@@ -385,13 +397,17 @@ mod tests {
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let csrf_token = res.take_string().await.unwrap();
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
 
         let mut res = TestClient::post("http://127.0.0.1:5801")
@@ -405,17 +421,25 @@ mod tests {
 
     #[tokio::test]
     async fn test_validates_token_in_query() {
-        let csrf = Csrf::new(BcryptCipher::new(), CookieStore::new(), HeaderFinder::new("csrf-token"));
+        let csrf = Csrf::new(
+            BcryptCipher::new(),
+            CookieStore::new(),
+            HeaderFinder::new("csrf-token"),
+        );
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let csrf_token = res.take_string().await.unwrap();
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
 
         let mut res = TestClient::post("http://127.0.0.1:5801?a=1&b=2")
@@ -437,13 +461,17 @@ mod tests {
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let csrf_token = res.take_string().await.unwrap();
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
 
         let mut res = TestClient::post("http://127.0.0.1:5801?a=1&b=2")
@@ -466,13 +494,17 @@ mod tests {
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let csrf_token = res.take_string().await.unwrap();
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
 
         let mut res = TestClient::post("http://127.0.0.1:5801")
@@ -493,13 +525,17 @@ mod tests {
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let csrf_token = res.take_string().await.unwrap();
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
         let mut res = TestClient::post("http://127.0.0.1:5801")
             .add_header("cookie", cookie.to_string(), true)
@@ -520,17 +556,25 @@ mod tests {
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
 
         let res = TestClient::post("http://127.0.0.1:5801")
             .add_header("x-csrf-token", "aGVsbG8=", true)
-            .add_header("cookie", cookie.to_string().split_once('.').unwrap().0, true)
+            .add_header(
+                "cookie",
+                cookie.to_string().split_once('.').unwrap().0,
+                true,
+            )
             .send(&service)
             .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
@@ -546,17 +590,25 @@ mod tests {
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
 
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
 
         let res = TestClient::post("http://127.0.0.1:5801")
             .add_header("x-csrf-token", "aGVsbG8", true)
-            .add_header("cookie", cookie.to_string().split_once('.').unwrap().0, true)
+            .add_header(
+                "cookie",
+                cookie.to_string().split_once('.').unwrap().0,
+                true,
+            )
             .send(&service)
             .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
@@ -572,20 +624,30 @@ mod tests {
         let router = Router::new().hoop(csrf).get(get_index).post(post_index);
         let service = Service::new(router);
 
-        let mut res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let mut res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
         let csrf_token = res.take_string().await.unwrap();
 
-        let res = TestClient::get("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::get("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::OK);
         let cookie = res.cookie("salvo.csrf").unwrap();
 
-        let res = TestClient::post("http://127.0.0.1:5801").send(&service).await;
+        let res = TestClient::post("http://127.0.0.1:5801")
+            .send(&service)
+            .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
 
         let res = TestClient::post("http://127.0.0.1:5801")
             .add_header("x-csrf-token", csrf_token, true)
-            .add_header("cookie", cookie.to_string().split_once('.').unwrap().0, true)
+            .add_header(
+                "cookie",
+                cookie.to_string().split_once('.').unwrap().0,
+                true,
+            )
             .send(&service)
             .await;
         assert_eq!(res.status_code.unwrap(), StatusCode::FORBIDDEN);
diff --git a/crates/flash/src/lib.rs b/crates/flash/src/lib.rs
index f44b4e8fe..f6c6d1287 100644
--- a/crates/flash/src/lib.rs
+++ b/crates/flash/src/lib.rs
@@ -182,7 +182,11 @@ impl Display for FlashLevel {
 /// `FlashStore` is for stores flash messages.
 pub trait FlashStore: Debug + Send + Sync + 'static {
     /// Get the flash messages from the store.
-    fn load_flash(&self, req: &mut Request, depot: &mut Depot) -> impl Future<Output = Option<Flash>> + Send;
+    fn load_flash(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+    ) -> impl Future<Output = Option<Flash>> + Send;
     /// Save the flash messages to the store.
     fn save_flash(
         &self,
@@ -192,7 +196,8 @@ pub trait FlashStore: Debug + Send + Sync + 'static {
         flash: Flash,
     ) -> impl Future<Output = ()> + Send;
     /// Clear the flash store.
-    fn clear_flash(&self, depot: &mut Depot, res: &mut Response) -> impl Future<Output = ()> + Send;
+    fn clear_flash(&self, depot: &mut Depot, res: &mut Response)
+        -> impl Future<Output = ()> + Send;
 }
 
 /// A trait for `Depot` to get flash messages.
@@ -251,7 +256,9 @@ impl<S> FlashHandler<S> {
 impl<S: FlashStore> fmt::Debug for FlashHandler<S> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_struct("FlashHandler").field("store", &self.store).finish()
+        f.debug_struct("FlashHandler")
+            .field("store", &self.store)
+            .finish()
     }
 }
 #[async_trait]
@@ -259,7 +266,13 @@ impl<S> Handler for FlashHandler<S>
 where
     S: FlashStore,
 {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         let mut has_incoming = false;
         if let Some(flash) = self.store.load_flash(req, depot).await {
             has_incoming = !flash.is_empty();
@@ -272,7 +285,9 @@ where
             return;
         }
 
-        let mut flash = depot.remove::<Flash>(OUTGOING_FLASH_KEY).unwrap_or_default();
+        let mut flash = depot
+            .remove::<Flash>(OUTGOING_FLASH_KEY)
+            .unwrap_or_default();
         if let Some(min_level) = self.minimum_level {
             flash.0.retain(|msg| msg.level >= min_level);
         }
@@ -322,7 +337,9 @@ mod tests {
             .push(Router::with_path("set").get(set_flash));
         let service = Service::new(router);
 
-        let respone = TestClient::get("http://127.0.0.1:5800/set").send(&service).await;
+        let respone = TestClient::get("http://127.0.0.1:5800/set")
+            .send(&service)
+            .await;
         assert_eq!(respone.status_code, Some(StatusCode::SEE_OTHER));
 
         let cookie = respone.headers().get(SET_COOKIE).unwrap();
@@ -362,7 +379,9 @@ mod tests {
             .push(Router::with_path("set").get(set_flash));
         let service = Service::new(router);
 
-        let respone = TestClient::get("http://127.0.0.1:5800/set").send(&service).await;
+        let respone = TestClient::get("http://127.0.0.1:5800/set")
+            .send(&service)
+            .await;
         assert_eq!(respone.status_code, Some(StatusCode::SEE_OTHER));
 
         let cookie = respone.headers().get(SET_COOKIE).unwrap();
diff --git a/crates/jwt-auth/src/decoder.rs b/crates/jwt-auth/src/decoder.rs
index f0b15a9fa..0d86ac682 100644
--- a/crates/jwt-auth/src/decoder.rs
+++ b/crates/jwt-auth/src/decoder.rs
@@ -49,13 +49,15 @@ impl ConstDecoder {
 
     /// If you're using HMAC with a base64 encoded secret, use this.
     pub fn from_base64_secret(secret: &str) -> Result<Self, JwtError> {
-        DecodingKey::from_base64_secret(secret).map(|key| Self::with_validation(key, Validation::default()))
+        DecodingKey::from_base64_secret(secret)
+            .map(|key| Self::with_validation(key, Validation::default()))
     }
 
     /// If you are loading a public RSA key in a PEM format, use this.
     /// Only exists if the feature `use_pem` is enabled.
     pub fn from_rsa_pem(key: &[u8]) -> Result<Self, JwtError> {
-        DecodingKey::from_rsa_pem(key).map(|key| Self::with_validation(key, Validation::new(Algorithm::RS256)))
+        DecodingKey::from_rsa_pem(key)
+            .map(|key| Self::with_validation(key, Validation::new(Algorithm::RS256)))
     }
 
     /// If you have (n, e) RSA public key components as strings, use this.
@@ -75,38 +77,51 @@ impl ConstDecoder {
     /// If you have a ECDSA public key in PEM format, use this.
     /// Only exists if the feature `use_pem` is enabled.
     pub fn from_ec_pem(key: &[u8]) -> Result<Self, JwtError> {
-        DecodingKey::from_ec_pem(key).map(|key| Self::with_validation(key, Validation::new(Algorithm::ES256)))
+        DecodingKey::from_ec_pem(key)
+            .map(|key| Self::with_validation(key, Validation::new(Algorithm::ES256)))
     }
 
     /// If you have (x,y) ECDSA key components
     pub fn from_ec_components(x: &str, y: &str) -> Result<Self, JwtError> {
-        DecodingKey::from_ec_components(x, y).map(|key| Self::with_validation(key, Validation::new(Algorithm::ES256)))
+        DecodingKey::from_ec_components(x, y)
+            .map(|key| Self::with_validation(key, Validation::new(Algorithm::ES256)))
     }
 
     /// If you have a EdDSA public key in PEM format, use this.
     /// Only exists if the feature `use_pem` is enabled.
     pub fn from_ed_pem(key: &[u8]) -> Result<Self, JwtError> {
-        DecodingKey::from_ed_pem(key).map(|key| Self::with_validation(key, Validation::new(Algorithm::EdDSA)))
+        DecodingKey::from_ed_pem(key)
+            .map(|key| Self::with_validation(key, Validation::new(Algorithm::EdDSA)))
     }
 
     /// If you know what you're doing and have a RSA DER encoded public key, use this.
     pub fn from_rsa_der(der: &[u8]) -> Self {
-        Self::with_validation(DecodingKey::from_rsa_der(der), Validation::new(Algorithm::RS256))
+        Self::with_validation(
+            DecodingKey::from_rsa_der(der),
+            Validation::new(Algorithm::RS256),
+        )
     }
 
     /// If you know what you're doing and have a RSA EC encoded public key, use this.
     pub fn from_ec_der(der: &[u8]) -> Self {
-        Self::with_validation(DecodingKey::from_ec_der(der), Validation::new(Algorithm::ES256))
+        Self::with_validation(
+            DecodingKey::from_ec_der(der),
+            Validation::new(Algorithm::ES256),
+        )
     }
 
     /// If you know what you're doing and have a Ed DER encoded public key, use this.
     pub fn from_ed_der(der: &[u8]) -> Self {
-        Self::with_validation(DecodingKey::from_ed_der(der), Validation::new(Algorithm::EdDSA))
+        Self::with_validation(
+            DecodingKey::from_ed_der(der),
+            Validation::new(Algorithm::EdDSA),
+        )
     }
 
     /// From x part (base64 encoded) of the JWK encoding
     pub fn from_ed_components(x: &str) -> Result<Self, JwtError> {
-        DecodingKey::from_ed_components(x).map(|key| Self::with_validation(key, Validation::new(Algorithm::EdDSA)))
+        DecodingKey::from_ed_components(x)
+            .map(|key| Self::with_validation(key, Validation::new(Algorithm::EdDSA)))
     }
 }
 
diff --git a/crates/jwt-auth/src/lib.rs b/crates/jwt-auth/src/lib.rs
index 312e563ec..0ff8ac8db 100644
--- a/crates/jwt-auth/src/lib.rs
+++ b/crates/jwt-auth/src/lib.rs
@@ -107,7 +107,9 @@
 use std::marker::PhantomData;
 
 #[doc(no_inline)]
-pub use jsonwebtoken::{decode, errors::Error as JwtError, Algorithm, DecodingKey, TokenData, Validation};
+pub use jsonwebtoken::{
+    decode, errors::Error as JwtError, Algorithm, DecodingKey, TokenData, Validation,
+};
 use serde::de::DeserializeOwned;
 use thiserror::Error;
 
@@ -319,7 +321,13 @@ where
     C: DeserializeOwned + Send + Sync + 'static,
     D: JwtAuthDecoder + Send + Sync + 'static,
 {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         let token = self.find_token(req).await;
         if let Some(token) = token {
             match self.decoder.decode::<C>(&token, depot).await {
@@ -365,8 +373,8 @@ mod tests {
     }
     #[tokio::test]
     async fn test_jwt_auth() {
-        let auth_handler: JwtAuth<JwtClaims, ConstDecoder> = JwtAuth::new(ConstDecoder::from_secret(b"ABCDEF"))
-            .finders(vec![
+        let auth_handler: JwtAuth<JwtClaims, ConstDecoder> =
+            JwtAuth::new(ConstDecoder::from_secret(b"ABCDEF")).finders(vec![
                 Box::new(HeaderFinder::new()),
                 Box::new(QueryFinder::new("jwt_token")),
                 Box::new(CookieFinder::new("jwt_token")),
diff --git a/crates/macros/src/extract.rs b/crates/macros/src/extract.rs
index f8a0dbe73..4e11b53b4 100644
--- a/crates/macros/src/extract.rs
+++ b/crates/macros/src/extract.rs
@@ -4,7 +4,10 @@ use syn::parse::Parse;
 use syn::parse::ParseStream;
 use syn::punctuated::Punctuated;
 use syn::token::Comma;
-use syn::{DeriveInput, Error, Expr, ExprLit, ExprPath, Field, Generics, Lit, Meta, MetaNameValue, Token, Type};
+use syn::{
+    DeriveInput, Error, Expr, ExprLit, ExprPath, Field, Generics, Lit, Meta, MetaNameValue, Token,
+    Type,
+};
 
 use crate::{
     attribute, omit_type_path_lifetimes, salvo_crate,
@@ -49,19 +52,27 @@ impl TryFrom<&Field> for FieldInfo {
         sources.dedup();
         aliases.dedup();
 
-        let (serde_rename, serde_flatten) =
-            if let Some(SerdeValue { rename, flatten, .. }) = serde_util::parse_value(&field.attrs) {
-                (rename, flatten)
-            } else {
-                (None, false)
-            };
+        let (serde_rename, serde_flatten) = if let Some(SerdeValue {
+            rename, flatten, ..
+        }) = serde_util::parse_value(&field.attrs)
+        {
+            (rename, flatten)
+        } else {
+            (None, false)
+        };
         let flatten = flatten.unwrap_or(serde_flatten);
         if flatten {
             if !sources.is_empty() {
-                return Err(Error::new_spanned(ident, "flatten field should not define souces."));
+                return Err(Error::new_spanned(
+                    ident,
+                    "flatten field should not define souces.",
+                ));
             }
             if !aliases.is_empty() {
-                return Err(Error::new_spanned(ident, "flatten field should not define aliases."));
+                return Err(Error::new_spanned(
+                    ident,
+                    "flatten field should not define aliases.",
+                ));
             }
         }
 
@@ -192,7 +203,8 @@ impl ExtractibleArgs {
         for attr in &attrs {
             if attr.path().is_ident("salvo") {
                 if let Ok(Some(metas)) = attribute::find_nested_list(attr, "extract") {
-                    let nested = metas.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated)?;
+                    let nested =
+                        metas.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated)?;
                     for meta in nested {
                         match meta {
                             Meta::List(meta) => {
@@ -202,7 +214,10 @@ impl ExtractibleArgs {
                             }
                             Meta::NameValue(meta) => {
                                 if meta.path.is_ident("rename_all") {
-                                    rename_all = Some(parse_path_or_lit_str(&meta.value)?.parse::<RenameRule>()?);
+                                    rename_all = Some(
+                                        parse_path_or_lit_str(&meta.value)?
+                                            .parse::<RenameRule>()?,
+                                    );
                                 }
                             }
                             _ => {}
@@ -225,7 +240,10 @@ impl ExtractibleArgs {
 }
 
 fn metadata_source(salvo: &Ident, source: &SourceInfo) -> TokenStream {
-    let from = Ident::new(&RenameRule::PascalCase.apply_to_field(&source.from), Span::call_site());
+    let from = Ident::new(
+        &RenameRule::PascalCase.apply_to_field(&source.from),
+        Span::call_site(),
+    );
     let parser = if source.parser.to_lowercase() == "multimap" {
         Ident::new("MultiMap", Span::call_site())
     } else {
@@ -320,7 +338,10 @@ pub(crate) fn generate(args: DeriveInput) -> Result<TokenStream, Error> {
             }
         }
         if nested_metadata.is_some() && field.sources.len() > 1 {
-            return Err(Error::new_spanned(name, "Only one source can be from request."));
+            return Err(Error::new_spanned(
+                name,
+                "Only one source can be from request.",
+            ));
         }
         let aliases = field.aliases.iter().map(|alias| {
             quote! {
@@ -368,8 +389,8 @@ pub(crate) fn generate(args: DeriveInput) -> Result<TokenStream, Error> {
     };
     let life_param = args.generics.lifetimes().next();
     let code = if let Some(life_param) = life_param {
-        let ex_life_def =
-            syn::parse_str(&format!("'__macro_gen_ex:{}", life_param.lifetime)).expect("Invalid lifetime.");
+        let ex_life_def = syn::parse_str(&format!("'__macro_gen_ex:{}", life_param.lifetime))
+            .expect("Invalid lifetime.");
         let mut generics = args.generics.clone();
         generics.params.insert(0, ex_life_def);
         let impl_generics_de = generics.split_for_impl().0;
@@ -408,7 +429,9 @@ pub(crate) fn generate(args: DeriveInput) -> Result<TokenStream, Error> {
 
 fn parse_path_or_lit_str(expr: &Expr) -> syn::Result<String> {
     match expr {
-        Expr::Lit(ExprLit { lit: Lit::Str(s), .. }) => Ok(s.value()),
+        Expr::Lit(ExprLit {
+            lit: Lit::Str(s), ..
+        }) => Ok(s.value()),
         Expr::Path(ExprPath { path, .. }) => Ok(path.require_ident()?.to_string()),
         _ => Err(Error::new_spanned(expr, "invalid indent or lit str")),
     }
diff --git a/crates/macros/src/handler.rs b/crates/macros/src/handler.rs
index 001780eb7..6c01892e2 100644
--- a/crates/macros/src/handler.rs
+++ b/crates/macros/src/handler.rs
@@ -52,7 +52,10 @@ pub(crate) fn generate(input: Item) -> syn::Result<TokenStream> {
                 }
             }
             let Some(hmtd) = hmtd else {
-                return Err(syn::Error::new_spanned(item_impl.impl_token, "missing handle function"));
+                return Err(syn::Error::new_spanned(
+                    item_impl.impl_token,
+                    "missing handle function",
+                ));
             };
             let hfn = handle_fn(&salvo, &hmtd.sig)?;
             let ty = &item_impl.self_ty;
@@ -102,7 +105,10 @@ fn handle_fn(salvo: &Ident, sig: &Signature) -> syn::Result<TokenStream> {
                     call_args.push(ident.ident.clone());
                     let ty = omit_type_path_lifetimes(ty);
                     let idv = pat.pat.to_token_stream().to_string();
-                    let idv = idv.rsplit_once(' ').map(|(_, v)| v.to_owned()).unwrap_or(idv);
+                    let idv = idv
+                        .rsplit_once(' ')
+                        .map(|(_, v)| v.to_owned())
+                        .unwrap_or(idv);
                     let id = Ident::new(&idv, Span::call_site());
                     let idv = idv.trim_start_matches('_');
 
diff --git a/crates/macros/src/shared.rs b/crates/macros/src/shared.rs
index e831ff5cf..cd956e0c7 100644
--- a/crates/macros/src/shared.rs
+++ b/crates/macros/src/shared.rs
@@ -39,7 +39,12 @@ pub(crate) fn parse_input_type(input: &FnArg) -> InputType {
                 // such as:
                 // `::std::vec::Vec` is `Vec`
                 // `Vec` is `Vec`
-                let ident = &nty.path.segments.last().expect("path segment should exists").ident;
+                let ident = &nty
+                    .path
+                    .segments
+                    .last()
+                    .expect("path segment should exists")
+                    .ident;
                 if ident == "Request" {
                     InputType::Request(p)
                 } else if ident == "Response" {
diff --git a/crates/oapi-macros/src/bound.rs b/crates/oapi-macros/src/bound.rs
index f1346c008..3ec1cc32c 100644
--- a/crates/oapi-macros/src/bound.rs
+++ b/crates/oapi-macros/src/bound.rs
@@ -23,7 +23,10 @@ pub(crate) fn without_defaults(generics: &syn::Generics) -> syn::Generics {
     }
 }
 
-pub(crate) fn with_where_predicates(generics: &syn::Generics, predicates: &[syn::WherePredicate]) -> syn::Generics {
+pub(crate) fn with_where_predicates(
+    generics: &syn::Generics,
+    predicates: &[syn::WherePredicate],
+) -> syn::Generics {
     let mut generics = generics.clone();
     generics
         .make_where_clause()
@@ -199,7 +202,10 @@ pub(crate) fn with_bound(
         fn visit_macro(&mut self, _mac: &'ast syn::Macro) {}
     }
 
-    let all_type_params = generics.type_params().map(|param| param.ident.clone()).collect();
+    let all_type_params = generics
+        .type_params()
+        .map(|param| param.ident.clone())
+        .collect();
 
     let mut visitor = FindTyParams {
         all_type_params,
@@ -243,6 +249,9 @@ pub(crate) fn with_bound(
         });
 
     let mut generics = generics.clone();
-    generics.make_where_clause().predicates.extend(new_predicates);
+    generics
+        .make_where_clause()
+        .predicates
+        .extend(new_predicates);
     generics
 }
diff --git a/crates/oapi-macros/src/component.rs b/crates/oapi-macros/src/component.rs
index 5262b6da2..e66a1209e 100644
--- a/crates/oapi-macros/src/component.rs
+++ b/crates/oapi-macros/src/component.rs
@@ -4,8 +4,8 @@ use syn::spanned::Spanned;
 
 use crate::doc_comment::CommentAttributes;
 use crate::feature::{
-    pop_feature, AdditionalProperties, Description, Feature, FeaturesExt, IsInline, Minimum, Nullable, TryToTokensExt,
-    Validatable,
+    pop_feature, AdditionalProperties, Description, Feature, FeaturesExt, IsInline, Minimum,
+    Nullable, TryToTokensExt, Validatable,
 };
 use crate::schema_type::{SchemaFormat, SchemaType, SchemaTypeInner};
 use crate::type_tree::{GenericType, TypeTree, ValueType};
@@ -78,14 +78,16 @@ impl<'c> ComponentSchema {
                     deprecated_stream,
                 )?
             }
-            Some(GenericType::Vec | GenericType::LinkedList | GenericType::Set) => ComponentSchema::vec_to_tokens(
-                &mut tokens,
-                features,
-                type_tree,
-                object_name,
-                description,
-                deprecated_stream,
-            )?,
+            Some(GenericType::Vec | GenericType::LinkedList | GenericType::Set) => {
+                ComponentSchema::vec_to_tokens(
+                    &mut tokens,
+                    features,
+                    type_tree,
+                    object_name,
+                    description,
+                    deprecated_stream,
+                )?
+            }
             #[cfg(feature = "smallvec")]
             Some(GenericType::SmallVec) => ComponentSchema::vec_to_tokens(
                 &mut tokens,
@@ -97,7 +99,10 @@ impl<'c> ComponentSchema {
             )?,
             Some(GenericType::Option) => {
                 // Add nullable feature if not already exists. Option is always nullable
-                if !features.iter().any(|feature| matches!(feature, Feature::Nullable(_))) {
+                if !features
+                    .iter()
+                    .any(|feature| matches!(feature, Feature::Nullable(_)))
+                {
                     features.push(Nullable::new().into());
                 }
 
@@ -116,7 +121,13 @@ impl<'c> ComponentSchema {
                 })?
                 .to_tokens(&mut tokens);
             }
-            Some(GenericType::Cow | GenericType::Box | GenericType::Arc | GenericType::Rc | GenericType::RefCell) => {
+            Some(
+                GenericType::Cow
+                | GenericType::Box
+                | GenericType::Arc
+                | GenericType::Rc
+                | GenericType::RefCell,
+            ) => {
                 ComponentSchema::new(ComponentSchemaProps {
                     type_tree: type_tree
                         .children
@@ -146,12 +157,17 @@ impl<'c> ComponentSchema {
     }
 
     /// Create `.schema_type(...)` override token stream if nullable is true from given [`SchemaTypeInner`].
-    fn get_schema_type_override(nullable: Option<Nullable>, schema_type_inner: SchemaTypeInner) -> Option<TokenStream> {
+    fn get_schema_type_override(
+        nullable: Option<Nullable>,
+        schema_type_inner: SchemaTypeInner,
+    ) -> Option<TokenStream> {
         if let Some(nullable) = nullable {
             let nullable_schema_type = nullable.into_schema_type_token_stream();
             let schema_type = if nullable.value() && !nullable_schema_type.is_empty() {
                 let oapi = crate::oapi_crate();
-                Some(quote! { #oapi::oapi::schema::SchemaType::from_iter([#schema_type_inner, #nullable_schema_type]) })
+                Some(
+                    quote! { #oapi::oapi::schema::SchemaType::from_iter([#schema_type_inner, #nullable_schema_type]) },
+                )
             } else {
                 None
             };
@@ -173,7 +189,8 @@ impl<'c> ComponentSchema {
         let oapi = crate::oapi_crate();
         let example = features.pop_by(|feature| matches!(feature, Feature::Example(_)));
         let additional_properties = pop_feature!(features => Feature::AdditionalProperties(_));
-        let nullable: Option<Nullable> = pop_feature!(features => Feature::Nullable(_)).into_inner();
+        let nullable: Option<Nullable> =
+            pop_feature!(features => Feature::Nullable(_)).into_inner();
         let default = pop_feature!(features => Feature::Default(_))
             .map(|f| f.try_to_token_stream())
             .transpose()?;
@@ -204,7 +221,8 @@ impl<'c> ComponentSchema {
                 Ok::<_, Diagnostic>(Some(quote! { .additional_properties(#schema_property) }))
             })?;
 
-        let schema_type = ComponentSchema::get_schema_type_override(nullable, SchemaTypeInner::Object);
+        let schema_type =
+            ComponentSchema::get_schema_type_override(nullable, SchemaTypeInner::Object);
 
         tokens.extend(quote! {
             #oapi::oapi::Object::new()
@@ -234,7 +252,8 @@ impl<'c> ComponentSchema {
         let xml = features.extract_vec_xml_feature(type_tree);
         let max_items = pop_feature!(features => Feature::MaxItems(_));
         let min_items = pop_feature!(features => Feature::MinItems(_));
-        let nullable: Option<Nullable> = pop_feature!(features => Feature::Nullable(_)).into_inner();
+        let nullable: Option<Nullable> =
+            pop_feature!(features => Feature::Nullable(_)).into_inner();
         let default = pop_feature!(features => Feature::Default(_))
             .map(|f| f.try_to_token_stream())
             .transpose()?;
@@ -264,7 +283,8 @@ impl<'c> ComponentSchema {
             },
             false => quote! {},
         };
-        let schema_type = ComponentSchema::get_schema_type_override(nullable, SchemaTypeInner::Array);
+        let schema_type =
+            ComponentSchema::get_schema_type_override(nullable, SchemaTypeInner::Array);
 
         let schema = quote! {
             #oapi::oapi::schema::Array::new().items(#component_schema)
@@ -277,7 +297,9 @@ impl<'c> ComponentSchema {
             let type_path = &**type_tree.path.as_ref().expect("path should not be `None`");
             let schema_type = SchemaType {
                 path: type_path,
-                nullable: nullable.map(|nullable| nullable.value()).unwrap_or_default(),
+                nullable: nullable
+                    .map(|nullable| nullable.value())
+                    .unwrap_or_default(),
             };
             feature.validate(&schema_type, type_tree)
         };
@@ -320,8 +342,11 @@ impl<'c> ComponentSchema {
         deprecated_stream: Option<TokenStream>,
     ) -> DiagResult<()> {
         let oapi = crate::oapi_crate();
-        let nullable_feat: Option<Nullable> = pop_feature!(features => Feature::Nullable(_)).into_inner();
-        let nullable = nullable_feat.map(|nullable| nullable.value()).unwrap_or_default();
+        let nullable_feat: Option<Nullable> =
+            pop_feature!(features => Feature::Nullable(_)).into_inner();
+        let nullable = nullable_feat
+            .map(|nullable| nullable.value())
+            .unwrap_or_default();
 
         match type_tree.value_type {
             ValueType::Primitive => {
@@ -333,7 +358,10 @@ impl<'c> ComponentSchema {
                 if schema_type.is_unsigned_integer() {
                     // add default minimum feature only when there is no explicit minimum
                     // provided
-                    if !features.iter().any(|feature| matches!(&feature, Feature::Minimum(_))) {
+                    if !features
+                        .iter()
+                        .any(|feature| matches!(&feature, Feature::Minimum(_)))
+                    {
                         features.push(Minimum::new(0f64, type_path.span()).into());
                     }
                 }
@@ -376,8 +404,10 @@ impl<'c> ComponentSchema {
 
                 if type_tree.is_object() {
                     let oapi = crate::oapi_crate();
-                    let nullable_schema_type =
-                        ComponentSchema::get_schema_type_override(nullable_feat, SchemaTypeInner::Object);
+                    let nullable_schema_type = ComponentSchema::get_schema_type_override(
+                        nullable_feat,
+                        SchemaTypeInner::Object,
+                    );
                     tokens.extend(quote! {
                         #oapi::oapi::Object::new()
                             #nullable_schema_type
@@ -471,8 +501,10 @@ impl<'c> ComponentSchema {
                                 all_of
                             },
                         );
-                        let nullable_schema_type =
-                            ComponentSchema::get_schema_type_override(nullable_feat, SchemaTypeInner::Array);
+                        let nullable_schema_type = ComponentSchema::get_schema_type_override(
+                            nullable_feat,
+                            SchemaTypeInner::Array,
+                        );
                         quote! {
                             #oapi::oapi::schema::Array::new().items(#all_of)
                                 #nullable_schema_type
diff --git a/crates/oapi-macros/src/doc_comment.rs b/crates/oapi-macros/src/doc_comment.rs
index 4adfcc892..a62172ac3 100644
--- a/crates/oapi-macros/src/doc_comment.rs
+++ b/crates/oapi-macros/src/doc_comment.rs
@@ -12,7 +12,9 @@ impl CommentAttributes {
     /// Creates new [`CommentAttributes`] instance from [`Attribute`] slice filtering out all
     /// other attributes which are not `doc` comments
     pub(crate) fn from_attributes(attributes: &[Attribute]) -> Self {
-        Self(Self::as_string_vec(attributes.iter().filter(Self::is_doc_attribute)))
+        Self(Self::as_string_vec(
+            attributes.iter().filter(Self::is_doc_attribute),
+        ))
     }
 
     fn is_doc_attribute(attr: &&Attribute) -> bool {
@@ -20,7 +22,10 @@ impl CommentAttributes {
     }
 
     fn as_string_vec<'a, I: Iterator<Item = &'a Attribute>>(attrs: I) -> Vec<String> {
-        attrs.into_iter().filter_map(Self::parse_doc_comment).collect()
+        attrs
+            .into_iter()
+            .filter_map(Self::parse_doc_comment)
+            .collect()
     }
 
     fn parse_doc_comment(attr: &Attribute) -> Option<String> {
diff --git a/crates/oapi-macros/src/endpoint/attr.rs b/crates/oapi-macros/src/endpoint/attr.rs
index 35492a5c9..6fcb144f0 100644
--- a/crates/oapi-macros/src/endpoint/attr.rs
+++ b/crates/oapi-macros/src/endpoint/attr.rs
@@ -4,7 +4,9 @@ use syn::{parenthesized, parse::Parse};
 use syn::{Expr, LitStr};
 
 use crate::operation::request_body::RequestBodyAttr;
-use crate::{parse_utils, security_requirement::SecurityRequirementsAttr, Array, Parameter, Response, Token};
+use crate::{
+    parse_utils, security_requirement::SecurityRequirementsAttr, Array, Parameter, Response, Token,
+};
 
 #[derive(Default, Debug)]
 pub(crate) struct EndpointAttr<'p> {
@@ -28,12 +30,16 @@ impl Parse for EndpointAttr<'_> {
         let mut attr = EndpointAttr::default();
 
         while !input.is_empty() {
-            let ident = input
-                .parse::<Ident>()
-                .map_err(|error| syn::Error::new(error.span(), format!("{EXPECTED_ATTRIBUTE_MESSAGE}, {error}")))?;
+            let ident = input.parse::<Ident>().map_err(|error| {
+                syn::Error::new(
+                    error.span(),
+                    format!("{EXPECTED_ATTRIBUTE_MESSAGE}, {error}"),
+                )
+            })?;
             match &*ident.to_string() {
                 "operation_id" => {
-                    attr.operation_id = Some(parse_utils::parse_next(input, || Expr::parse(input))?);
+                    attr.operation_id =
+                        Some(parse_utils::parse_next(input, || Expr::parse(input))?);
                 }
                 "request_body" => {
                     attr.request_body = Some(input.parse::<RequestBodyAttr>()?);
@@ -41,27 +47,36 @@ impl Parse for EndpointAttr<'_> {
                 "responses" => {
                     let responses;
                     parenthesized!(responses in input);
-                    attr.responses = Punctuated::<Response, Token![,]>::parse_terminated(&responses)
-                        .map(|punctuated| punctuated.into_iter().collect::<Vec<Response>>())?;
+                    attr.responses =
+                        Punctuated::<Response, Token![,]>::parse_terminated(&responses)
+                            .map(|punctuated| punctuated.into_iter().collect::<Vec<Response>>())?;
                 }
                 "status_codes" => {
                     let status_codes;
                     parenthesized!(status_codes in input);
-                    attr.status_codes = Punctuated::<Expr, Token![,]>::parse_terminated(&status_codes)
-                        .map(|punctuated| punctuated.into_iter().collect::<Vec<Expr>>())?;
+                    attr.status_codes =
+                        Punctuated::<Expr, Token![,]>::parse_terminated(&status_codes)
+                            .map(|punctuated| punctuated.into_iter().collect::<Vec<Expr>>())?;
                 }
                 "parameters" => {
                     let parameters;
                     parenthesized!(parameters in input);
-                    attr.parameters = Punctuated::<Parameter, Token![,]>::parse_terminated(&parameters)
-                        .map(|punctuated| punctuated.into_iter().collect::<Vec<Parameter>>())?;
+                    attr.parameters =
+                        Punctuated::<Parameter, Token![,]>::parse_terminated(&parameters)
+                            .map(|punctuated| punctuated.into_iter().collect::<Vec<Parameter>>())?;
                 }
                 "tags" => {
                     let tags;
                     parenthesized!(tags in input);
                     attr.tags = Some(
-                        Punctuated::<LitStr, Token![,]>::parse_terminated(&tags)
-                            .map(|punctuated| punctuated.into_iter().map(|t| t.value()).collect::<Vec<_>>())?,
+                        Punctuated::<LitStr, Token![,]>::parse_terminated(&tags).map(
+                            |punctuated| {
+                                punctuated
+                                    .into_iter()
+                                    .map(|t| t.value())
+                                    .collect::<Vec<_>>()
+                            },
+                        )?,
                     );
                 }
                 "security" => {
@@ -69,7 +84,9 @@ impl Parse for EndpointAttr<'_> {
                     parenthesized!(security in input);
                     attr.security = Some(parse_utils::parse_groups(&security)?)
                 }
-                "description" => attr.description = Some(parse_utils::parse_next_lit_str_or_expr(input)?),
+                "description" => {
+                    attr.description = Some(parse_utils::parse_next_lit_str_or_expr(input)?)
+                }
                 "summary" => attr.summary = Some(parse_utils::parse_next_lit_str_or_expr(input)?),
                 _ => {
                     return Err(syn::Error::new(ident.span(), EXPECTED_ATTRIBUTE_MESSAGE));
diff --git a/crates/oapi-macros/src/endpoint/mod.rs b/crates/oapi-macros/src/endpoint/mod.rs
index 17f5f0150..a83947a4b 100644
--- a/crates/oapi-macros/src/endpoint/mod.rs
+++ b/crates/oapi-macros/src/endpoint/mod.rs
@@ -146,7 +146,10 @@ pub(crate) fn generate(mut attr: EndpointAttr, input: Item) -> syn::Result<Token
                 }
             }
             let Some(hmtd) = hmtd else {
-                return Err(syn::Error::new_spanned(item_impl.impl_token, "missing handle function"));
+                return Err(syn::Error::new_spanned(
+                    item_impl.impl_token,
+                    "missing handle function",
+                ));
             };
             let (hfn, modifiers) = handle_fn(&salvo, &oapi, &hmtd.sig)?;
             let ty = &item_impl.self_ty;
@@ -170,7 +173,11 @@ pub(crate) fn generate(mut attr: EndpointAttr, input: Item) -> syn::Result<Token
     }
 }
 
-fn handle_fn(salvo: &Ident, oapi: &Ident, sig: &Signature) -> syn::Result<(TokenStream, Vec<TokenStream>)> {
+fn handle_fn(
+    salvo: &Ident,
+    oapi: &Ident,
+    sig: &Signature,
+) -> syn::Result<(TokenStream, Vec<TokenStream>)> {
     let name = &sig.ident;
     let mut extract_ts = Vec::with_capacity(sig.inputs.len());
     let mut call_args: Vec<Ident> = Vec::with_capacity(sig.inputs.len());
@@ -201,7 +208,10 @@ fn handle_fn(salvo: &Ident, oapi: &Ident, sig: &Signature) -> syn::Result<(Token
                     let ty = omit_type_path_lifetimes(ty);
                     let idv = pat.pat.to_token_stream().to_string();
                     // If id like `mut pdata`, then idv is `pdata`;
-                    let idv = idv.rsplit_once(' ').map(|(_, v)| v.to_owned()).unwrap_or(idv);
+                    let idv = idv
+                        .rsplit_once(' ')
+                        .map(|(_, v)| v.to_owned())
+                        .unwrap_or(idv);
                     let id = Ident::new(&idv, Span::call_site());
                     let idv = idv.trim_start_matches('_');
                     extract_ts.push(quote!{
diff --git a/crates/oapi-macros/src/feature/ext.rs b/crates/oapi-macros/src/feature/ext.rs
index 6cd53155e..f5dde4696 100644
--- a/crates/oapi-macros/src/feature/ext.rs
+++ b/crates/oapi-macros/src/feature/ext.rs
@@ -45,7 +45,9 @@ pub(crate) trait FeaturesExt {
 
 impl FeaturesExt for Vec<Feature> {
     fn pop_by(&mut self, op: impl FnMut(&Feature) -> bool) -> Option<Feature> {
-        self.iter().position(op).map(|index| self.swap_remove(index))
+        self.iter()
+            .position(op)
+            .map(|index| self.swap_remove(index))
     }
 
     fn pop_value_type_feature(&mut self) -> Option<ValueType> {
@@ -113,23 +115,28 @@ impl FeaturesExt for Option<Vec<Feature>> {
     }
 
     fn pop_value_type_feature(&mut self) -> Option<ValueType> {
-        self.as_mut().and_then(|features| features.pop_value_type_feature())
+        self.as_mut()
+            .and_then(|features| features.pop_value_type_feature())
     }
 
     fn pop_parameter_in_feature(&mut self) -> Option<ParameterIn> {
-        self.as_mut().and_then(|features| features.pop_parameter_in_feature())
+        self.as_mut()
+            .and_then(|features| features.pop_parameter_in_feature())
     }
 
     fn pop_style_feature(&mut self) -> Option<Style> {
-        self.as_mut().and_then(|features| features.pop_style_feature())
+        self.as_mut()
+            .and_then(|features| features.pop_style_feature())
     }
 
     fn pop_rename_feature(&mut self) -> Option<Rename> {
-        self.as_mut().and_then(|features| features.pop_rename_feature())
+        self.as_mut()
+            .and_then(|features| features.pop_rename_feature())
     }
 
     fn pop_rename_all_feature(&mut self) -> Option<RenameAll> {
-        self.as_mut().and_then(|features| features.pop_rename_all_feature())
+        self.as_mut()
+            .and_then(|features| features.pop_rename_all_feature())
     }
 
     fn extract_vec_xml_feature(&mut self, type_tree: &TypeTree) -> Option<Feature> {
diff --git a/crates/oapi-macros/src/feature/items.rs b/crates/oapi-macros/src/feature/items.rs
index a2b50bc81..42507315d 100644
--- a/crates/oapi-macros/src/feature/items.rs
+++ b/crates/oapi-macros/src/feature/items.rs
@@ -48,9 +48,12 @@ impl Parse for Examples {
         parenthesized!(examples in input);
 
         Ok(Self(
-            Punctuated::<AnyValue, Token![,]>::parse_terminated_with(&examples, AnyValue::parse_any)?
-                .into_iter()
-                .collect(),
+            Punctuated::<AnyValue, Token![,]>::parse_terminated_with(
+                &examples,
+                AnyValue::parse_any,
+            )?
+            .into_iter()
+            .collect(),
         ))
     }
 }
@@ -126,7 +129,10 @@ pub(crate) struct XmlAttr(pub(crate) schema::XmlAttr);
 impl XmlAttr {
     /// Split [`XmlAttr`] for [`GenericType::Vec`] returning tuple of [`XmlAttr`]s where first
     /// one is for a vec and second one is for object field.
-    pub(crate) fn split_for_vec(&mut self, type_tree: &TypeTree) -> DiagResult<(Option<XmlAttr>, Option<XmlAttr>)> {
+    pub(crate) fn split_for_vec(
+        &mut self,
+        type_tree: &TypeTree,
+    ) -> DiagResult<(Option<XmlAttr>, Option<XmlAttr>)> {
         if matches!(type_tree.generic_type, Some(GenericType::Vec)) {
             let mut value_xml = mem::take(self);
             let vec_xml = schema::XmlAttr::with_wrapped(
@@ -797,7 +803,8 @@ impl Parse for Pattern {
     where
         Self: Sized,
     {
-        parse_utils::parse_next(input, || input.parse::<LitStr>()).map(|pattern| Self(pattern.value(), ident))
+        parse_utils::parse_next(input, || input.parse::<LitStr>())
+            .map(|pattern| Self(pattern.value(), ident))
     }
 }
 impl ToTokens for Pattern {
diff --git a/crates/oapi-macros/src/feature/mod.rs b/crates/oapi-macros/src/feature/mod.rs
index 361ae4b08..c2a528208 100644
--- a/crates/oapi-macros/src/feature/mod.rs
+++ b/crates/oapi-macros/src/feature/mod.rs
@@ -114,28 +114,36 @@ pub(crate) enum Feature {
 }
 
 impl Feature {
-    pub(crate) fn validate(&self, schema_type: &SchemaType, type_tree: &TypeTree) -> DiagResult<()> {
+    pub(crate) fn validate(
+        &self,
+        schema_type: &SchemaType,
+        type_tree: &TypeTree,
+    ) -> DiagResult<()> {
         match self {
-            Feature::MultipleOf(multiple_of) => {
-                multiple_of.validate(ValidatorChain::new(&IsNumber(schema_type)).next(&AboveZeroF64(multiple_of.0)))
-            }
+            Feature::MultipleOf(multiple_of) => multiple_of.validate(
+                ValidatorChain::new(&IsNumber(schema_type)).next(&AboveZeroF64(multiple_of.0)),
+            ),
             Feature::Maximum(maximum) => maximum.validate(IsNumber(schema_type)),
             Feature::Minimum(minimum) => minimum.validate(IsNumber(schema_type)),
-            Feature::ExclusiveMaximum(exclusive_maximum) => exclusive_maximum.validate(IsNumber(schema_type)),
-            Feature::ExclusiveMinimum(exclusive_minimum) => exclusive_minimum.validate(IsNumber(schema_type)),
-            Feature::MaxLength(max_length) => {
-                max_length.validate(ValidatorChain::new(&IsString(schema_type)).next(&AboveZeroUsize(max_length.0)))
+            Feature::ExclusiveMaximum(exclusive_maximum) => {
+                exclusive_maximum.validate(IsNumber(schema_type))
             }
-            Feature::MinLength(min_length) => {
-                min_length.validate(ValidatorChain::new(&IsString(schema_type)).next(&AboveZeroUsize(min_length.0)))
+            Feature::ExclusiveMinimum(exclusive_minimum) => {
+                exclusive_minimum.validate(IsNumber(schema_type))
             }
+            Feature::MaxLength(max_length) => max_length.validate(
+                ValidatorChain::new(&IsString(schema_type)).next(&AboveZeroUsize(max_length.0)),
+            ),
+            Feature::MinLength(min_length) => min_length.validate(
+                ValidatorChain::new(&IsString(schema_type)).next(&AboveZeroUsize(min_length.0)),
+            ),
             Feature::Pattern(pattern) => pattern.validate(IsString(schema_type)),
-            Feature::MaxItems(max_items) => {
-                max_items.validate(ValidatorChain::new(&AboveZeroUsize(max_items.0)).next(&IsVec(type_tree)))
-            }
-            Feature::MinItems(min_items) => {
-                min_items.validate(ValidatorChain::new(&AboveZeroUsize(min_items.0)).next(&IsVec(type_tree)))
-            }
+            Feature::MaxItems(max_items) => max_items.validate(
+                ValidatorChain::new(&AboveZeroUsize(max_items.0)).next(&IsVec(type_tree)),
+            ),
+            Feature::MinItems(min_items) => min_items.validate(
+                ValidatorChain::new(&AboveZeroUsize(min_items.0)).next(&IsVec(type_tree)),
+            ),
             _unsupported_variant => {
                 const SUPPORTED_VARIANTS: [&str; 10] = [
                     "multiple_of",
@@ -366,7 +374,9 @@ impl Validatable for Feature {
             Feature::Description(description) => description.is_validatable(),
             Feature::Deprecated(deprecated) => deprecated.is_validatable(),
             Feature::Skip(skip) => skip.is_validatable(),
-            Feature::AdditionalProperties(additional_properites) => additional_properites.is_validatable(),
+            Feature::AdditionalProperties(additional_properites) => {
+                additional_properites.is_validatable()
+            }
             Feature::Required(required) => required.is_validatable(),
             Feature::SkipBound(skip) => skip.is_validatable(),
             Feature::Bound(bound) => bound.is_validatable(),
diff --git a/crates/oapi-macros/src/operation/example.rs b/crates/oapi-macros/src/operation/example.rs
index 5bc0443c7..a60eb9e41 100644
--- a/crates/oapi-macros/src/operation/example.rs
+++ b/crates/oapi-macros/src/operation/example.rs
@@ -77,7 +77,10 @@ impl Parse for Example {
 impl ToTokens for Example {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let oapi = crate::oapi_crate();
-        let summary = self.summary.as_ref().map(|summary| quote!(.summary(#summary)));
+        let summary = self
+            .summary
+            .as_ref()
+            .map(|summary| quote!(.summary(#summary)));
         let description = self
             .description
             .as_ref()
diff --git a/crates/oapi-macros/src/operation/mod.rs b/crates/oapi-macros/src/operation/mod.rs
index 6b5f8df0d..920b96922 100644
--- a/crates/oapi-macros/src/operation/mod.rs
+++ b/crates/oapi-macros/src/operation/mod.rs
@@ -38,25 +38,33 @@ impl<'a> Operation<'a> {
             .and_then(|comments| comments.split_first())
             .map(|(summary, description)| {
                 // Skip all whitespace lines
-                let start_pos = description.iter().position(|s| !s.chars().all(char::is_whitespace));
+                let start_pos = description
+                    .iter()
+                    .position(|s| !s.chars().all(char::is_whitespace));
 
-                let trimmed = start_pos.and_then(|pos| description.get(pos..)).unwrap_or(description);
+                let trimmed = start_pos
+                    .and_then(|pos| description.get(pos..))
+                    .unwrap_or(description);
 
                 (summary, trimmed)
             });
 
-        let summary = attr
-            .summary
-            .as_ref()
-            .map(Summary::Value)
-            .or_else(|| split_comment.as_ref().map(|(summary, _)| Summary::Str(summary)));
-
-        let description = attr.description.as_ref().map(Description::Value).or_else(|| {
+        let summary = attr.summary.as_ref().map(Summary::Value).or_else(|| {
             split_comment
                 .as_ref()
-                .map(|(_, description)| Description::Vec(description))
+                .map(|(summary, _)| Summary::Str(summary))
         });
 
+        let description = attr
+            .description
+            .as_ref()
+            .map(Description::Value)
+            .or_else(|| {
+                split_comment
+                    .as_ref()
+                    .map(|(_, description)| Description::Vec(description))
+            });
+
         Self {
             deprecated: &attr.deprecated,
             operation_id: attr.operation_id.as_ref(),
@@ -163,7 +171,8 @@ impl<'a> Operation<'a> {
                             }
                             ResponseTupleInner::Value(value) => {
                                 if let Some(content) = &value.response_type {
-                                    modifiers.append(&mut generate_register_schemas(&oapi, content));
+                                    modifiers
+                                        .append(&mut generate_register_schemas(&oapi, content));
                                 }
                             }
                         }
diff --git a/crates/oapi-macros/src/operation/request_body.rs b/crates/oapi-macros/src/operation/request_body.rs
index 8bbaa6294..73272e0c2 100644
--- a/crates/oapi-macros/src/operation/request_body.rs
+++ b/crates/oapi-macros/src/operation/request_body.rs
@@ -75,26 +75,33 @@ impl Parse for RequestBodyAttr<'_> {
 
                 match attr_name {
                     "content" => {
-                        request_body_attr.content =
-                            Some(parse_utils::parse_next(&group, || group.parse()).map_err(|error| {
+                        request_body_attr.content = Some(
+                            parse_utils::parse_next(&group, || group.parse()).map_err(|error| {
                                 Error::new(
                                     error.span(),
-                                    format!("unexpected token, expected type such as String, {error}",),
+                                    format!(
+                                        "unexpected token, expected type such as String, {error}",
+                                    ),
                                 )
-                            })?);
+                            })?,
+                        );
                     }
                     "content_type" => {
-                        request_body_attr.content_type = Some(parse_utils::parse_next_lit_str_or_expr(&group)?)
+                        request_body_attr.content_type =
+                            Some(parse_utils::parse_next_lit_str_or_expr(&group)?)
                     }
                     "description" => {
-                        request_body_attr.description = Some(parse_utils::parse_next_lit_str_or_expr(&group)?)
+                        request_body_attr.description =
+                            Some(parse_utils::parse_next_lit_str_or_expr(&group)?)
                     }
                     "example" => {
-                        request_body_attr.example =
-                            Some(parse_utils::parse_next(&group, || AnyValue::parse_json(&group))?)
+                        request_body_attr.example = Some(parse_utils::parse_next(&group, || {
+                            AnyValue::parse_json(&group)
+                        })?)
                     }
                     "examples" => {
-                        request_body_attr.examples = Some(parse_utils::parse_punctuated_within_parenthesis(&group)?)
+                        request_body_attr.examples =
+                            Some(parse_utils::parse_punctuated_within_parenthesis(&group)?)
                     }
                     _ => return Err(Error::new(ident.span(), EXPECTED_ATTRIBUTE_MESSAGE)),
                 }
@@ -192,7 +199,9 @@ impl TryToTokens for RequestBodyAttr<'_> {
                     });
                 }
                 PathType::InlineSchema(_, _) => {
-                    unreachable!("`PathType::InlineSchema` is not implemented for `RequestBodyAttr`");
+                    unreachable!(
+                        "`PathType::InlineSchema` is not implemented for `RequestBodyAttr`"
+                    );
                 }
             }
         }
diff --git a/crates/oapi-macros/src/parameter/derive.rs b/crates/oapi-macros/src/parameter/derive.rs
index 56830cddd..a7c3dfe8c 100644
--- a/crates/oapi-macros/src/parameter/derive.rs
+++ b/crates/oapi-macros/src/parameter/derive.rs
@@ -4,22 +4,26 @@ use proc_macro2::{Span, TokenStream};
 use quote::{quote, ToTokens};
 use syn::spanned::Spanned;
 use syn::{
-    parse::Parse, punctuated::Punctuated, Attribute, Data, Field, GenericParam, Generics, Ident, Lifetime,
-    LifetimeParam, Token,
+    parse::Parse, punctuated::Punctuated, Attribute, Data, Field, GenericParam, Generics, Ident,
+    Lifetime, LifetimeParam, Token,
 };
 
 use crate::component::{self, ComponentSchema};
 use crate::doc_comment::CommentAttributes;
 use crate::feature::{
-    self, impl_into_inner, impl_merge, parse_features, pop_feature, AdditionalProperties, AllowReserved, DefaultStyle,
-    Example, ExclusiveMaximum, ExclusiveMinimum, Explode, Feature, FeaturesExt, Format, Inline, MaxItems, MaxLength,
-    Maximum, Merge, MinItems, MinLength, Minimum, MultipleOf, Nullable, Pattern, ReadOnly, Rename, RenameAll,
-    SchemaWith, Style, ToParametersNames, TryToTokensExt, WriteOnly, XmlAttr,
+    self, impl_into_inner, impl_merge, parse_features, pop_feature, AdditionalProperties,
+    AllowReserved, DefaultStyle, Example, ExclusiveMaximum, ExclusiveMinimum, Explode, Feature,
+    FeaturesExt, Format, Inline, MaxItems, MaxLength, Maximum, Merge, MinItems, MinLength, Minimum,
+    MultipleOf, Nullable, Pattern, ReadOnly, Rename, RenameAll, SchemaWith, Style,
+    ToParametersNames, TryToTokensExt, WriteOnly, XmlAttr,
 };
 use crate::parameter::ParameterIn;
 use crate::serde_util::{self, RenameRule, SerdeContainer, SerdeValue};
 use crate::type_tree::TypeTree;
-use crate::{attribute, Array, DiagLevel, DiagResult, Diagnostic, FieldRename, IntoInner, Required, TryToTokens};
+use crate::{
+    attribute, Array, DiagLevel, DiagResult, Diagnostic, FieldRename, IntoInner, Required,
+    TryToTokens,
+};
 
 impl_merge!(ToParametersFeatures, FieldFeatures);
 
@@ -68,7 +72,11 @@ impl TryToTokens for ToParameters {
             .attrs
             .iter()
             .filter(|attr| attr.path().is_ident("salvo"))
-            .filter_map(|attr| attribute::find_nested_list(attr, "parameters").ok().flatten())
+            .filter_map(|attr| {
+                attribute::find_nested_list(attr, "parameters")
+                    .ok()
+                    .flatten()
+            })
             .map(|meta| {
                 meta.parse_args::<ToParametersFeatures>()
                     .map_err(Diagnostic::from)
@@ -81,7 +89,11 @@ impl TryToTokens for ToParameters {
 
         // #[param] is only supported over fields
         if self.attrs.iter().any(|attr| {
-            attr.path().is_ident("salvo") && attribute::find_nested_list(attr, "parameter").ok().flatten().is_some()
+            attr.path().is_ident("salvo")
+                && attribute::find_nested_list(attr, "parameter")
+                    .ok()
+                    .flatten()
+                    .is_some()
         }) {
             return Err(Diagnostic::spanned(
                 ident.span(),
@@ -93,25 +105,27 @@ impl TryToTokens for ToParameters {
 
         let names = parameters_features.as_mut().and_then(|features| {
             let to_parameters_names = pop_feature!(features => Feature::ToParametersNames(_));
-            IntoInner::<Option<ToParametersNames>>::into_inner(to_parameters_names).map(|names| names.into_values())
+            IntoInner::<Option<ToParametersNames>>::into_inner(to_parameters_names)
+                .map(|names| names.into_values())
         });
 
         let default_style = pop_feature!(parameters_features => Feature::DefaultStyle(_));
-        let default_parameter_in = pop_feature!(parameters_features => Feature::DefaultParameterIn(_));
+        let default_parameter_in =
+            pop_feature!(parameters_features => Feature::DefaultParameterIn(_));
         let rename_all = pop_feature!(parameters_features => Feature::RenameAll(_));
-        let default_source_from =
-            if let Some(Feature::DefaultParameterIn(feature::DefaultParameterIn(default_parameter_in))) =
-                default_parameter_in
-            {
-                match default_parameter_in {
-                    ParameterIn::Query => quote! { #salvo::extract::metadata::SourceFrom::Query },
-                    ParameterIn::Header => quote! { #salvo::extract::metadata::SourceFrom::Header },
-                    ParameterIn::Path => quote! { #salvo::extract::metadata::SourceFrom::Param },
-                    ParameterIn::Cookie => quote! { #salvo::extract::metadata::SourceFrom::Cookie },
-                }
-            } else {
-                quote! { #salvo::extract::metadata::SourceFrom::Query }
-            };
+        let default_source_from = if let Some(Feature::DefaultParameterIn(
+            feature::DefaultParameterIn(default_parameter_in),
+        )) = default_parameter_in
+        {
+            match default_parameter_in {
+                ParameterIn::Query => quote! { #salvo::extract::metadata::SourceFrom::Query },
+                ParameterIn::Header => quote! { #salvo::extract::metadata::SourceFrom::Header },
+                ParameterIn::Path => quote! { #salvo::extract::metadata::SourceFrom::Param },
+                ParameterIn::Cookie => quote! { #salvo::extract::metadata::SourceFrom::Cookie },
+            }
+        } else {
+            quote! { #salvo::extract::metadata::SourceFrom::Query }
+        };
         let default_source = quote! { #salvo::extract::metadata::Source::new(#default_source_from, #salvo::extract::metadata::SourceParser::MultiMap) };
         let params = self
             .get_struct_fields(&names.as_ref())?
@@ -190,15 +204,17 @@ impl TryToTokens for ToParameters {
                 _ => None,
             })
             .unwrap_or_else(|| None);
-        let serde_rename_all =
-            if let Some(serde_rename_all) = serde_container.as_ref().and_then(|container| container.rename_all) {
-                let rule = quote_rename_rule(&salvo, &serde_rename_all);
-                Some(quote! {
-                    .serde_rename_all(#rule)
-                })
-            } else {
-                None
-            };
+        let serde_rename_all = if let Some(serde_rename_all) = serde_container
+            .as_ref()
+            .and_then(|container| container.rename_all)
+        {
+            let rule = quote_rename_rule(&salvo, &serde_rename_all);
+            Some(quote! {
+                .serde_rename_all(#rule)
+            })
+        } else {
+            None
+        };
 
         let name = ident.to_string();
         let params = params
@@ -245,7 +261,10 @@ impl ToParameters {
     fn is_named_struct(&self) -> bool {
         matches!(&self.data, Data::Struct(data_struct) if matches!(&data_struct.fields, syn::Fields::Named(_)))
     }
-    fn get_struct_fields(&self, field_names: &Option<&Vec<String>>) -> DiagResult<impl Iterator<Item = &Field>> {
+    fn get_struct_fields(
+        &self,
+        field_names: &Option<&Vec<String>>,
+    ) -> DiagResult<impl Iterator<Item = &Field>> {
         let ident = &self.ident;
         let abort = |note: &str| {
             let msg = format!("unsupported data type, expected struct with named fields `struct {} {{...}}` or unnamed fields `struct {}(...)`",
@@ -451,7 +470,9 @@ impl Parameter<'_> {
             .expect("struct field name should be exists")
             .to_string();
 
-        let rename = param_features.pop_rename_feature().map(|rename| rename.into_value());
+        let rename = param_features
+            .pop_rename_feature()
+            .map(|rename| rename.into_value());
         let rename = rename.map(|rename| quote!(.rename(#rename)));
         let serde_rename = self.field_serde_params.as_ref().map(|field_param_serde| {
             field_param_serde
@@ -518,7 +539,9 @@ impl TryToTokens for Parameter<'_> {
             .or_else(|| {
                 self.field_serde_params
                     .as_ref()
-                    .and_then(|field_param_serde| field_param_serde.rename.as_deref().map(Cow::Borrowed))
+                    .and_then(|field_param_serde| {
+                        field_param_serde.rename.as_deref().map(Cow::Borrowed)
+                    })
             });
         let rename_all = self
             .container_attributes
@@ -529,7 +552,8 @@ impl TryToTokens for Parameter<'_> {
                     .as_ref()
                     .and_then(|serde_container| serde_container.rename_all.as_ref())
             });
-        let name = crate::rename::<FieldRename>(name, rename, rename_all).unwrap_or(Cow::Borrowed(name));
+        let name =
+            crate::rename::<FieldRename>(name, rename, rename_all).unwrap_or(Cow::Borrowed(name));
         let type_tree = TypeTree::from_type(&field.ty)?;
 
         tokens.extend(quote! { #oapi::oapi::parameter::Parameter::new(#name)});
@@ -556,7 +580,8 @@ impl TryToTokens for Parameter<'_> {
         if let Some(schema_with) = schema_with {
             tokens.extend(quote! { .schema(#schema_with) });
         } else {
-            let description = CommentAttributes::from_attributes(&field.attrs).as_formatted_string();
+            let description =
+                CommentAttributes::from_attributes(&field.attrs).as_formatted_string();
             if !description.is_empty() {
                 tokens.extend(quote! { .description(#description)})
             }
@@ -568,9 +593,10 @@ impl TryToTokens for Parameter<'_> {
                 .transpose()?
                 .unwrap_or(type_tree);
 
-            let required: Option<feature::Required> = pop_feature!(param_features => Feature::Required(_)).into_inner();
-            let component_required =
-                !component.is_option() && crate::is_required(self.field_serde_params.as_ref(), self.serde_container);
+            let required: Option<feature::Required> =
+                pop_feature!(param_features => Feature::Required(_)).into_inner();
+            let component_required = !component.is_option()
+                && crate::is_required(self.field_serde_params.as_ref(), self.serde_container);
 
             let required = match (required, component_required) {
                 (Some(required_feature), _) => Into::<Required>::into(required_feature.is_true()),
diff --git a/crates/oapi-macros/src/parameter/mod.rs b/crates/oapi-macros/src/parameter/mod.rs
index 852ef4606..c9ec7c392 100644
--- a/crates/oapi-macros/src/parameter/mod.rs
+++ b/crates/oapi-macros/src/parameter/mod.rs
@@ -12,9 +12,9 @@ use derive::ToParameters;
 use crate::{
     component::{self, ComponentSchema},
     feature::{
-        parse_features, AllowReserved, Description, Example, ExclusiveMaximum, ExclusiveMinimum, Explode, Feature,
-        Format, MaxItems, MaxLength, Maximum, MinItems, MinLength, Minimum, MultipleOf, Nullable, Pattern, ReadOnly,
-        Style, TryToTokensExt, WriteOnly, XmlAttr,
+        parse_features, AllowReserved, Description, Example, ExclusiveMaximum, ExclusiveMinimum,
+        Explode, Feature, Format, MaxItems, MaxLength, Maximum, MinItems, MinLength, Minimum,
+        MultipleOf, Nullable, Pattern, ReadOnly, Style, TryToTokensExt, WriteOnly, XmlAttr,
     },
     operation::InlineType,
     parse_utils, Required,
@@ -59,7 +59,9 @@ pub(crate) enum Parameter<'a> {
 impl Parse for Parameter<'_> {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         if input.fork().parse::<ExprPath>().is_ok() {
-            Ok(Self::Struct(StructParameter { path: input.parse()? }))
+            Ok(Self::Struct(StructParameter {
+                path: input.parse()?,
+            }))
         } else {
             Ok(Self::Value(input.parse()?))
         }
@@ -184,7 +186,9 @@ impl Parse for ValueParameter<'_> {
             input.parse::<Token![,]>().ok();
         }
 
-        let (schema_features, parameter_features) = input.parse::<ParameterFeatures>()?.split_for_parameter_type();
+        let (schema_features, parameter_features) = input
+            .parse::<ParameterFeatures>()?
+            .split_for_parameter_type();
 
         parameter.features = (schema_features.clone(), parameter_features);
         if let Some(parameter_schema) = &mut parameter.parameter_schema {
@@ -311,7 +315,8 @@ pub(crate) enum ParameterIn {
 }
 
 impl ParameterIn {
-    pub(crate) const VARIANTS: &'static [Self] = &[Self::Query, Self::Path, Self::Header, Self::Cookie];
+    pub(crate) const VARIANTS: &'static [Self] =
+        &[Self::Query, Self::Path, Self::Header, Self::Cookie];
 }
 
 impl Display for ParameterIn {
@@ -393,17 +398,27 @@ impl ToTokens for ParameterStyle {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let oapi = crate::oapi_crate();
         match self {
-            ParameterStyle::Matrix => tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::Matrix }),
-            ParameterStyle::Label => tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::Label }),
-            ParameterStyle::Form => tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::Form }),
-            ParameterStyle::Simple => tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::Simple }),
+            ParameterStyle::Matrix => {
+                tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::Matrix })
+            }
+            ParameterStyle::Label => {
+                tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::Label })
+            }
+            ParameterStyle::Form => {
+                tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::Form })
+            }
+            ParameterStyle::Simple => {
+                tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::Simple })
+            }
             ParameterStyle::SpaceDelimited => {
                 tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::SpaceDelimited })
             }
             ParameterStyle::PipeDelimited => {
                 tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::PipeDelimited })
             }
-            ParameterStyle::DeepObject => tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::DeepObject }),
+            ParameterStyle::DeepObject => {
+                tokens.extend(quote! { #oapi::oapi::parameter::ParameterStyle::DeepObject })
+            }
         }
     }
 }
diff --git a/crates/oapi-macros/src/parse_utils.rs b/crates/oapi-macros/src/parse_utils.rs
index c9888d465..42b47674a 100644
--- a/crates/oapi-macros/src/parse_utils.rs
+++ b/crates/oapi-macros/src/parse_utils.rs
@@ -61,7 +61,10 @@ impl Display for Value {
     }
 }
 
-pub(crate) fn parse_next<T: Sized>(input: ParseStream, next: impl FnOnce() -> syn::Result<T>) -> syn::Result<T> {
+pub(crate) fn parse_next<T: Sized>(
+    input: ParseStream,
+    next: impl FnOnce() -> syn::Result<T>,
+) -> syn::Result<T> {
     input.parse::<Token![=]>()?;
     next()
 }
@@ -96,7 +99,9 @@ where
     })
 }
 
-pub(crate) fn parse_punctuated_within_parenthesis<T>(input: ParseStream) -> syn::Result<Punctuated<T, Token![,]>>
+pub(crate) fn parse_punctuated_within_parenthesis<T>(
+    input: ParseStream,
+) -> syn::Result<Punctuated<T, Token![,]>>
 where
     T: Parse,
 {
@@ -132,7 +137,10 @@ pub(crate) fn parse_json_token_stream(input: ParseStream) -> syn::Result<TokenSt
 
         Ok(input.parse::<Group>()?.stream())
     } else {
-        Err(syn::Error::new(input.span(), "unexpected token, expected json!(...)"))
+        Err(syn::Error::new(
+            input.span(),
+            "unexpected token, expected json!(...)",
+        ))
     }
 }
 
diff --git a/crates/oapi-macros/src/response/derive.rs b/crates/oapi-macros/src/response/derive.rs
index 66e59a94c..2596fe522 100644
--- a/crates/oapi-macros/src/response/derive.rs
+++ b/crates/oapi-macros/src/response/derive.rs
@@ -6,7 +6,9 @@ use quote::quote;
 use syn::parse::ParseStream;
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{Attribute, Data, Field, Fields, Generics, LitStr, Meta, Path, Token, Type, TypePath, Variant};
+use syn::{
+    Attribute, Data, Field, Fields, Generics, LitStr, Meta, Path, Token, Type, TypePath, Variant,
+};
 
 use crate::doc_comment::CommentAttributes;
 use crate::operation::{InlineType, PathType};
@@ -14,8 +16,8 @@ use crate::schema::{EnumSchema, NamedStructSchema};
 use crate::{attribute, parse_utils, Array, DiagLevel, DiagResult, Diagnostic, TryToTokens};
 
 use super::{
-    Content, DeriveResponseValue, DeriveResponsesAttributes, DeriveToResponseValue, DeriveToResponsesValue,
-    ResponseTuple, ResponseValue,
+    Content, DeriveResponseValue, DeriveResponsesAttributes, DeriveToResponseValue,
+    DeriveToResponsesValue, ResponseTuple, ResponseValue,
 };
 
 pub(crate) struct ToResponse<'a> {
@@ -33,9 +35,15 @@ impl<'a> ToResponse<'a> {
     ) -> DiagResult<ToResponse<'a>> {
         let response = match &data {
             Data::Struct(struct_value) => match &struct_value.fields {
-                Fields::Named(fields) => ToResponseNamedStructResponse::new(attributes, ident, &fields.named)?.0,
+                Fields::Named(fields) => {
+                    ToResponseNamedStructResponse::new(attributes, ident, &fields.named)?.0
+                }
                 Fields::Unnamed(fields) => {
-                    let field = fields.unnamed.iter().next().expect("unnamed struct must have 1 field");
+                    let field = fields
+                        .unnamed
+                        .iter()
+                        .next()
+                        .expect("unnamed struct must have 1 field");
                     ToResponseUnnamedStructResponse::new(attributes, &field.ty, &field.attrs)?.0
                 }
                 Fields::Unit => ToResponseUnitStructResponse::new(attributes)?.0,
@@ -100,15 +108,21 @@ impl TryToTokens for ToResponses<'_> {
         let responses = match &self.data {
             Data::Struct(struct_value) => match &struct_value.fields {
                 Fields::Named(fields) => {
-                    let response = NamedStructResponse::new(self.attributes, self.ident, &fields.named)?.0;
+                    let response =
+                        NamedStructResponse::new(self.attributes, self.ident, &fields.named)?.0;
                     let status_code = &response.status_code;
                     let response = response.try_to_token_stream()?;
                     Array::from_iter(iter::once(quote!((#status_code, #response))))
                 }
                 Fields::Unnamed(fields) => {
-                    let field = fields.unnamed.iter().next().expect("Unnamed struct must have 1 field");
-
-                    let response = UnnamedStructResponse::new(self.attributes, &field.ty, &field.attrs)?.0;
+                    let field = fields
+                        .unnamed
+                        .iter()
+                        .next()
+                        .expect("Unnamed struct must have 1 field");
+
+                    let response =
+                        UnnamedStructResponse::new(self.attributes, &field.ty, &field.attrs)?.0;
                     let status_code = &response.status_code;
                     let response = response.try_to_token_stream()?;
                     Array::from_iter(iter::once(quote!((#status_code, #response))))
@@ -124,9 +138,12 @@ impl TryToTokens for ToResponses<'_> {
                 .variants
                 .iter()
                 .map(|variant| match &variant.fields {
-                    Fields::Named(fields) => {
-                        Ok(NamedStructResponse::new(&variant.attrs, &variant.ident, &fields.named)?.0)
-                    }
+                    Fields::Named(fields) => Ok(NamedStructResponse::new(
+                        &variant.attrs,
+                        &variant.ident,
+                        &fields.named,
+                    )?
+                    .0),
                     Fields::Unnamed(fields) => {
                         let field = fields
                             .unnamed
@@ -186,10 +203,13 @@ trait Response {
     }
 
     fn has_no_field_attributes(attr: &Attribute) -> (bool, &'static str) {
-        const ERROR: &str = "Unexpected field attribute, field attributes are only supported at unnamed fields";
+        const ERROR: &str =
+            "Unexpected field attribute, field attributes are only supported at unnamed fields";
 
         if let Some(metas) = attribute::find_nested_list(attr, "response").ok().flatten() {
-            if let Ok(metas) = metas.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated) {
+            if let Ok(metas) =
+                metas.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)
+            {
                 for meta in metas {
                     if meta.path().is_ident("name") || meta.path().is_ident("content") {
                         return (false, ERROR);
@@ -207,7 +227,11 @@ trait Response {
         attributes.into_iter().filter_map(move |attribute| {
             let (valid, message) = validate(attribute);
             if !valid {
-                Some(Diagnostic::spanned(attribute.span(), DiagLevel::Error, message))
+                Some(Diagnostic::spanned(
+                    attribute.span(),
+                    DiagLevel::Error,
+                    message,
+                ))
             } else {
                 None
             }
@@ -220,10 +244,15 @@ struct UnnamedStructResponse<'u>(ResponseTuple<'u>);
 impl Response for UnnamedStructResponse<'_> {}
 
 impl<'u> UnnamedStructResponse<'u> {
-    fn new(attributes: &[Attribute], ty: &'u Type, inner_attributes: &[Attribute]) -> DiagResult<Self> {
+    fn new(
+        attributes: &[Attribute],
+        ty: &'u Type,
+        inner_attributes: &[Attribute],
+    ) -> DiagResult<Self> {
         let mut is_inline = false;
         for attr in inner_attributes {
-            if attr.path().is_ident("salvo") && attribute::has_nested_path(attr, "response", "inline").unwrap_or(false)
+            if attr.path().is_ident("salvo")
+                && attribute::has_nested_path(attr, "response", "inline").unwrap_or(false)
             {
                 is_inline = true;
                 break;
@@ -239,12 +268,11 @@ impl<'u> UnnamedStructResponse<'u> {
         Ok(Self(
             (
                 status_code,
-                ResponseValue::from_derive_to_responses_value(derive_value, description).response_type(
-                    PathType::MediaType(InlineType {
+                ResponseValue::from_derive_to_responses_value(derive_value, description)
+                    .response_type(PathType::MediaType(InlineType {
                         ty: Cow::Borrowed(ty),
                         is_inline,
-                    }),
-                ),
+                    })),
             )
                 .into(),
         ))
@@ -256,7 +284,11 @@ struct NamedStructResponse<'n>(ResponseTuple<'n>);
 impl Response for NamedStructResponse<'_> {}
 
 impl NamedStructResponse<'_> {
-    fn new(attributes: &[Attribute], ident: &Ident, fields: &Punctuated<Field, Token![,]>) -> DiagResult<Self> {
+    fn new(
+        attributes: &[Attribute],
+        ident: &Ident,
+        fields: &Punctuated<Field, Token![,]>,
+    ) -> DiagResult<Self> {
         if let Some(diag) = Self::validate_attributes(attributes, Self::has_no_field_attributes)
             .chain(Self::validate_attributes(
                 fields.iter().flat_map(|field| &field.attrs),
@@ -294,7 +326,10 @@ impl NamedStructResponse<'_> {
             (
                 status_code,
                 ResponseValue::from_derive_to_responses_value(derive_value, description)
-                    .response_type(PathType::InlineSchema(inline_schema.try_to_token_stream()?, ty)),
+                    .response_type(PathType::InlineSchema(
+                        inline_schema.try_to_token_stream()?,
+                        ty,
+                    )),
             )
                 .into(),
         ))
@@ -307,7 +342,9 @@ impl Response for UnitStructResponse<'_> {}
 
 impl UnitStructResponse<'_> {
     fn new(attributes: &[Attribute]) -> DiagResult<Self> {
-        if let Some(diagnostics) = Self::validate_attributes(attributes, Self::has_no_field_attributes).next() {
+        if let Some(diagnostics) =
+            Self::validate_attributes(attributes, Self::has_no_field_attributes).next()
+        {
             return Err(diagnostics);
         }
 
@@ -334,7 +371,11 @@ struct ToResponseNamedStructResponse<'p>(ResponseTuple<'p>);
 impl Response for ToResponseNamedStructResponse<'_> {}
 
 impl<'p> ToResponseNamedStructResponse<'p> {
-    fn new(attributes: &[Attribute], ident: &Ident, fields: &Punctuated<Field, Token![,]>) -> DiagResult<Self> {
+    fn new(
+        attributes: &[Attribute],
+        ident: &Ident,
+        fields: &Punctuated<Field, Token![,]>,
+    ) -> DiagResult<Self> {
         if let Some(diag) = Self::validate_attributes(attributes, Self::has_no_field_attributes)
             .chain(Self::validate_attributes(
                 fields.iter().flat_map(|field| &field.attrs),
@@ -381,7 +422,11 @@ struct ToResponseUnnamedStructResponse<'c>(ResponseTuple<'c>);
 impl Response for ToResponseUnnamedStructResponse<'_> {}
 
 impl<'u> ToResponseUnnamedStructResponse<'u> {
-    fn new(attributes: &[Attribute], ty: &'u Type, inner_attributes: &[Attribute]) -> DiagResult<Self> {
+    fn new(
+        attributes: &[Attribute],
+        ty: &'u Type,
+        inner_attributes: &[Attribute],
+    ) -> DiagResult<Self> {
         if let Some(diag) = Self::validate_attributes(attributes, Self::has_no_field_attributes)
             .chain(Self::validate_attributes(inner_attributes, |attribute| {
                 const ERROR: &str = "Unexpected attribute, `content` is only supported on unnamed field enum variant";
@@ -404,7 +449,9 @@ impl<'u> ToResponseUnnamedStructResponse<'u> {
 
         let mut is_inline = false;
         for attr in inner_attributes {
-            if attr.path().is_ident("salvo") && attribute::has_nested_path(attr, "schema", "inline").unwrap_or(false) {
+            if attr.path().is_ident("salvo")
+                && attribute::has_nested_path(attr, "schema", "inline").unwrap_or(false)
+            {
                 is_inline = true;
                 break;
             }
@@ -434,7 +481,11 @@ struct EnumResponse<'r>(ResponseTuple<'r>);
 impl Response for EnumResponse<'_> {}
 
 impl<'r> EnumResponse<'r> {
-    fn new(ident: &Ident, variants: &'r Punctuated<Variant, Token![,]>, attributes: &[Attribute]) -> DiagResult<Self> {
+    fn new(
+        ident: &Ident,
+        variants: &'r Punctuated<Variant, Token![,]>,
+        attributes: &[Attribute],
+    ) -> DiagResult<Self> {
         if let Some(diag) = Self::validate_attributes(attributes, Self::has_no_field_attributes)
             .chain(Self::validate_attributes(
                 variants.iter().flat_map(|variant| &variant.attrs),
@@ -482,9 +533,18 @@ impl<'r> EnumResponse<'r> {
             description,
         });
         response_value.response_type = if contents.is_empty() {
-            let inline_schema = EnumSchema::new(Cow::Owned(ident.to_string()), variants, attributes, None, None)?;
-
-            Some(PathType::InlineSchema(inline_schema.try_to_token_stream()?, ty))
+            let inline_schema = EnumSchema::new(
+                Cow::Owned(ident.to_string()),
+                variants,
+                attributes,
+                None,
+                None,
+            )?;
+
+            Some(PathType::InlineSchema(
+                inline_schema.try_to_token_stream()?,
+                ty,
+            ))
         } else {
             None
         };
@@ -494,7 +554,8 @@ impl<'r> EnumResponse<'r> {
     }
 
     fn parse_variant_attributes(variant: &Variant) -> DiagResult<VariantAttributes> {
-        let variant_derive_response_value = DeriveToResponseValue::from_attributes(variant.attrs.as_slice())?;
+        let variant_derive_response_value =
+            DeriveToResponseValue::from_attributes(variant.attrs.as_slice())?;
         // named enum variant should not have field attributes
         if let Fields::Named(named_fields) = &variant.fields {
             if let Some(diagnostic) = Self::validate_attributes(
@@ -513,7 +574,8 @@ impl<'r> EnumResponse<'r> {
         if let Some(attrs) = field.map(|f| &f.attrs) {
             for attr in attrs {
                 if attr.path().is_ident("salvo") {
-                    if let Some(metas) = attribute::find_nested_list(attr, "content").ok().flatten() {
+                    if let Some(metas) = attribute::find_nested_list(attr, "content").ok().flatten()
+                    {
                         content_type = Some(
                             metas
                                 .parse_args_with(|input: ParseStream| input.parse::<LitStr>())
@@ -581,7 +643,9 @@ impl Response for ToResponseUnitStructResponse<'_> {}
 
 impl ToResponseUnitStructResponse<'_> {
     fn new(attributes: &[Attribute]) -> DiagResult<Self> {
-        if let Some(diag) = Self::validate_attributes(attributes, Self::has_no_field_attributes).next() {
+        if let Some(diag) =
+            Self::validate_attributes(attributes, Self::has_no_field_attributes).next()
+        {
             return Err(diag);
         }
 
diff --git a/crates/oapi-macros/src/response/mod.rs b/crates/oapi-macros/src/response/mod.rs
index 12d347a1f..d7ca52bf6 100644
--- a/crates/oapi-macros/src/response/mod.rs
+++ b/crates/oapi-macros/src/response/mod.rs
@@ -9,7 +9,9 @@ use syn::{parenthesized, Attribute, DeriveInput, Error, ExprPath, LitInt, LitStr
 
 use crate::component::ComponentSchema;
 use crate::feature::Inline;
-use crate::operation::{example::Example, status::STATUS_CODES, InlineType, PathType, PathTypeTree};
+use crate::operation::{
+    example::Example, status::STATUS_CODES, InlineType, PathType, PathTypeTree,
+};
 use crate::type_tree::TypeTree;
 use crate::{attribute, parse_utils, AnyValue, Array, DiagResult, Diagnostic, TryToTokens};
 
@@ -81,7 +83,11 @@ impl<'r> ResponseTuple<'r> {
         if self.inner.is_none() {
             self.inner = Some(ResponseTupleInner::Value(ResponseValue::default()));
         }
-        if let ResponseTupleInner::Value(val) = self.inner.as_mut().expect("inner value shoule not be `None`") {
+        if let ResponseTupleInner::Value(val) = self
+            .inner
+            .as_mut()
+            .expect("inner value shoule not be `None`")
+        {
             Ok(val)
         } else {
             Err(Error::new(span, RESPONSE_INCOMPATIBLE_ATTRIBUTES_MSG))
@@ -93,7 +99,9 @@ impl<'r> ResponseTuple<'r> {
         match &mut self.inner {
             None => self.inner = Some(ResponseTupleInner::Ref(ty)),
             Some(ResponseTupleInner::Ref(r)) => *r = ty,
-            Some(ResponseTupleInner::Value(_)) => return Err(Error::new(span, RESPONSE_INCOMPATIBLE_ATTRIBUTES_MSG)),
+            Some(ResponseTupleInner::Value(_)) => {
+                return Err(Error::new(span, RESPONSE_INCOMPATIBLE_ATTRIBUTES_MSG))
+            }
         }
         Ok(())
     }
@@ -112,14 +120,18 @@ impl Parse for ResponseTuple<'_> {
         let mut response = ResponseTuple::default();
 
         while !input.is_empty() {
-            let ident = input
-                .parse::<Ident>()
-                .map_err(|error| Error::new(error.span(), format!("{EXPECTED_ATTRIBUTE_MESSAGE}, {error}")))?;
+            let ident = input.parse::<Ident>().map_err(|error| {
+                Error::new(
+                    error.span(),
+                    format!("{EXPECTED_ATTRIBUTE_MESSAGE}, {error}"),
+                )
+            })?;
             let attr_name = &*ident.to_string();
 
             match attr_name {
                 "status_code" => {
-                    response.status_code = parse_utils::parse_next(input, || input.parse::<ResponseStatusCode>())?;
+                    response.status_code =
+                        parse_utils::parse_next(input, || input.parse::<ResponseStatusCode>())?;
                 }
                 "description" => {
                     response.as_value(input.span())?.description = parse::description(input)?;
@@ -129,7 +141,8 @@ impl Parse for ResponseTuple<'_> {
                         Some(parse_utils::parse_next(input, || input.parse())?);
                 }
                 "content_type" => {
-                    response.as_value(input.span())?.content_type = Some(parse::content_type(input)?);
+                    response.as_value(input.span())?.content_type =
+                        Some(parse::content_type(input)?);
                 }
                 "headers" => {
                     response.as_value(input.span())?.headers = parse::headers(input)?;
@@ -145,7 +158,10 @@ impl Parse for ResponseTuple<'_> {
                         parse_utils::parse_punctuated_within_parenthesis(input)?;
                 }
                 "response" => {
-                    response.set_ref_type(input.span(), parse_utils::parse_next(input, || input.parse())?)?;
+                    response.set_ref_type(
+                        input.span(),
+                        parse_utils::parse_next(input, || input.parse())?,
+                    )?;
                 }
                 _ => return Err(Error::new(ident.span(), EXPECTED_ATTRIBUTE_MESSAGE)),
             }
@@ -222,7 +238,10 @@ pub(crate) struct ResponseValue<'r> {
 }
 
 impl<'r> ResponseValue<'r> {
-    fn from_derive_to_response_value(derive_value: DeriveToResponseValue, description: parse_utils::Value) -> Self {
+    fn from_derive_to_response_value(
+        derive_value: DeriveToResponseValue,
+        description: parse_utils::Value,
+    ) -> Self {
         Self {
             description: if derive_value.description.is_empty() && !description.is_empty() {
                 description
@@ -237,7 +256,10 @@ impl<'r> ResponseValue<'r> {
         }
     }
 
-    fn from_derive_to_responses_value(response_value: DeriveToResponsesValue, description: parse_utils::Value) -> Self {
+    fn from_derive_to_responses_value(
+        response_value: DeriveToResponsesValue,
+        description: parse_utils::Value,
+    ) -> Self {
         ResponseValue {
             description: if response_value.description.is_empty() && !description.is_empty() {
                 description
@@ -261,7 +283,11 @@ impl<'r> ResponseValue<'r> {
 impl TryToTokens for ResponseTuple<'_> {
     fn try_to_tokens(&self, tokens: &mut TokenStream) -> DiagResult<()> {
         let oapi = crate::oapi_crate();
-        match self.inner.as_ref().expect("inner value should not be `None`") {
+        match self
+            .inner
+            .as_ref()
+            .expect("inner value should not be `None`")
+        {
             ResponseTupleInner::Ref(res) => {
                 let path = &res.ty;
                 tokens.extend(quote_spanned! {path.span()=>
@@ -523,7 +549,8 @@ impl Parse for DeriveToResponsesValue {
             .map_err(|error| Error::new(error.span(), MISSING_STATUS_ERROR))?;
 
         if status_ident == "status_code" {
-            response.status_code = parse_utils::parse_next(input, || input.parse::<ResponseStatusCode>())?;
+            response.status_code =
+                parse_utils::parse_next(input, || input.parse::<ResponseStatusCode>())?;
         } else {
             return Err(Error::new(status_ident.span(), MISSING_STATUS_ERROR));
         }
@@ -675,12 +702,20 @@ impl Parse for Content<'_> {
             let ident = content.parse::<Ident>()?;
             let attr_name = &*ident.to_string();
             match attr_name {
-                "example" => example = Some(parse_utils::parse_next(&content, || AnyValue::parse_json(&content))?),
-                "examples" => examples = Some(parse_utils::parse_punctuated_within_parenthesis(&content)?),
+                "example" => {
+                    example = Some(parse_utils::parse_next(&content, || {
+                        AnyValue::parse_json(&content)
+                    })?)
+                }
+                "examples" => {
+                    examples = Some(parse_utils::parse_punctuated_within_parenthesis(&content)?)
+                }
                 _ => {
                     return Err(Error::new(
                         ident.span(),
-                        format!("unexpected attribute: {ident}, expected one of: example, examples"),
+                        format!(
+                            "unexpected attribute: {ident}, expected one of: example, examples"
+                        ),
                     ));
                 }
             }
@@ -816,7 +851,10 @@ impl Parse for Header {
                 })
                 .and_then(|ident| {
                     if ident != "description" {
-                        return Err(Error::new(ident.span(), "unexpected attribute, expected: description"));
+                        return Err(Error::new(
+                            ident.span(),
+                            "unexpected attribute, expected: description",
+                        ));
                     }
                     Ok(ident)
                 })?;
diff --git a/crates/oapi-macros/src/schema/enum_schemas.rs b/crates/oapi-macros/src/schema/enum_schemas.rs
index 31bf1d908..547225af8 100644
--- a/crates/oapi-macros/src/schema/enum_schemas.rs
+++ b/crates/oapi-macros/src/schema/enum_schemas.rs
@@ -10,8 +10,8 @@ use syn::{Attribute, Fields, Generics, Token, Variant};
 use crate::component::ComponentDescription;
 use crate::doc_comment::CommentAttributes;
 use crate::feature::{
-    parse_features, pop_feature, pop_feature_as_inner, Alias, Bound, Example, Feature, FeaturesExt, IsSkipped, Name,
-    Rename, RenameAll, SkipBound, TryToTokensExt,
+    parse_features, pop_feature, pop_feature_as_inner, Alias, Bound, Example, Feature, FeaturesExt,
+    IsSkipped, Name, Rename, RenameAll, SkipBound, TryToTokensExt,
 };
 use crate::schema::{Description, Inline, VariantRename};
 use crate::serde_util::{self, SerdeContainer, SerdeEnumRepr, SerdeValue};
@@ -19,11 +19,12 @@ use crate::type_tree::{TypeTree, ValueType};
 use crate::{DiagLevel, DiagResult, Diagnostic, IntoInner, TryToTokens};
 
 use super::enum_variant::{
-    self, AdjacentlyTaggedEnum, CustomEnum, Enum, ObjectVariant, SimpleEnumVariant, TaggedEnum, UntaggedEnum,
+    self, AdjacentlyTaggedEnum, CustomEnum, Enum, ObjectVariant, SimpleEnumVariant, TaggedEnum,
+    UntaggedEnum,
 };
 use super::feature::{
-    self, ComplexEnumFeatures, EnumFeatures, EnumNamedFieldVariantFeatures, EnumUnnamedFieldVariantFeatures,
-    FromAttributes,
+    self, ComplexEnumFeatures, EnumFeatures, EnumNamedFieldVariantFeatures,
+    EnumUnnamedFieldVariantFeatures, FromAttributes,
 };
 use super::{is_not_skipped, NamedStructSchema, SchemaFeatureExt, UnnamedStructSchema};
 
@@ -45,7 +46,10 @@ impl<'e> EnumSchema<'e> {
         aliases: Option<Punctuated<Alias, Comma>>,
         generics: Option<&'e Generics>,
     ) -> DiagResult<Self> {
-        if variants.iter().all(|variant| matches!(variant.fields, Fields::Unit)) {
+        if variants
+            .iter()
+            .all(|variant| matches!(variant.fields, Fields::Unit))
+        {
             #[cfg(feature = "repr")]
             {
                 attributes
@@ -58,22 +62,26 @@ impl<'e> EnumSchema<'e> {
                         }
                     })
                     .map(|enum_type| {
-                        let mut repr_enum_features = feature::parse_schema_features_with(attributes, |input| {
-                            Ok(parse_features!(
-                                input as crate::feature::Example,
-                                crate::feature::Examples,
-                                crate::feature::Default,
-                                crate::feature::Name,
-                                crate::feature::Title,
-                                crate::feature::Inline
-                            ))
-                        })?
-                        .unwrap_or_default();
+                        let mut repr_enum_features =
+                            feature::parse_schema_features_with(attributes, |input| {
+                                Ok(parse_features!(
+                                    input as crate::feature::Example,
+                                    crate::feature::Examples,
+                                    crate::feature::Default,
+                                    crate::feature::Name,
+                                    crate::feature::Title,
+                                    crate::feature::Inline
+                                ))
+                            })?
+                            .unwrap_or_default();
 
                         let name = pop_feature_as_inner!(repr_enum_features => Feature::Name(_v));
 
-                        let inline: Option<Inline> = pop_feature_as_inner!(repr_enum_features => Feature::Inline(_v));
-                        let description = pop_feature!(repr_enum_features => Feature::Description(_)).into_inner();
+                        let inline: Option<Inline> =
+                            pop_feature_as_inner!(repr_enum_features => Feature::Inline(_v));
+                        let description =
+                            pop_feature!(repr_enum_features => Feature::Description(_))
+                                .into_inner();
                         Ok(Self {
                             schema_type: EnumSchemaType::Repr(ReprEnum {
                                 variants,
@@ -97,8 +105,11 @@ impl<'e> EnumSchema<'e> {
                         let name = pop_feature_as_inner!(simple_enum_features => Feature::Name(_v));
 
                         let rename_all = simple_enum_features.pop_rename_all_feature();
-                        let inline: Option<Inline> = pop_feature_as_inner!(simple_enum_features => Feature::Inline(_v));
-                        let description = pop_feature!(simple_enum_features => Feature::Description(_)).into_inner();
+                        let inline: Option<Inline> =
+                            pop_feature_as_inner!(simple_enum_features => Feature::Inline(_v));
+                        let description =
+                            pop_feature!(simple_enum_features => Feature::Description(_))
+                                .into_inner();
                         Ok(Self {
                             schema_type: EnumSchemaType::Simple(SimpleEnum {
                                 attributes,
@@ -122,7 +133,9 @@ impl<'e> EnumSchema<'e> {
                     .into_inner()
                     .unwrap_or_default();
 
-                let generic_count = generics.map(|g| g.type_params().count()).unwrap_or_default();
+                let generic_count = generics
+                    .map(|g| g.type_params().count())
+                    .unwrap_or_default();
                 let name = pop_feature_as_inner!(simple_enum_features => Feature::Name(_v));
                 if generic_count == 0 && !aliases.as_ref().map(|a| a.is_empty()).unwrap_or(true) {
                     return Err(Diagnostic::new(
@@ -132,8 +145,10 @@ impl<'e> EnumSchema<'e> {
                 }
 
                 let rename_all = simple_enum_features.pop_rename_all_feature();
-                let inline: Option<Inline> = pop_feature_as_inner!(simple_enum_features => Feature::Inline(_v));
-                let description = pop_feature!(simple_enum_features => Feature::Description(_)).into_inner();
+                let inline: Option<Inline> =
+                    pop_feature_as_inner!(simple_enum_features => Feature::Inline(_v));
+                let description =
+                    pop_feature!(simple_enum_features => Feature::Description(_)).into_inner();
                 Ok(Self {
                     schema_type: EnumSchemaType::Simple(SimpleEnum {
                         attributes,
@@ -154,7 +169,9 @@ impl<'e> EnumSchema<'e> {
                 .into_inner()
                 .unwrap_or_default();
 
-            let generic_count = generics.map(|g| g.type_params().count()).unwrap_or_default();
+            let generic_count = generics
+                .map(|g| g.type_params().count())
+                .unwrap_or_default();
             let name = pop_feature_as_inner!(enum_features => Feature::Name(_v));
             if generic_count == 0 && !aliases.as_ref().map(|a| a.is_empty()).unwrap_or(true) {
                 return Err(Diagnostic::new(
@@ -164,7 +181,8 @@ impl<'e> EnumSchema<'e> {
             }
 
             let rename_all = enum_features.pop_rename_all_feature();
-            let inline: Option<Inline> = pop_feature_as_inner!(enum_features => Feature::Inline(_v));
+            let inline: Option<Inline> =
+                pop_feature_as_inner!(enum_features => Feature::Inline(_v));
             let description = pop_feature!(enum_features => Feature::Description(_)).into_inner();
             Ok(Self {
                 schema_type: EnumSchemaType::Complex(ComplexEnum {
@@ -308,7 +326,9 @@ fn rename_enum_variant<'a>(
     container_rules: &'a Option<SerdeContainer>,
     rename_all: &'a Option<RenameAll>,
 ) -> Option<Cow<'a, str>> {
-    let rename = features.pop_rename_feature().map(|rename| rename.into_value());
+    let rename = features
+        .pop_rename_feature()
+        .map(|rename| rename.into_value());
     let rename_to = variant_rules
         .as_ref()
         .and_then(|variant_rules| variant_rules.rename.as_deref().map(Cow::Borrowed))
@@ -317,7 +337,11 @@ fn rename_enum_variant<'a>(
     let rename_all = container_rules
         .as_ref()
         .and_then(|container_rules| container_rules.rename_all.as_ref())
-        .or_else(|| rename_all.as_ref().map(|rename_all| rename_all.as_rename_rule()));
+        .or_else(|| {
+            rename_all
+                .as_ref()
+                .map(|rename_all| rename_all.as_rename_rule())
+        });
 
     crate::rename::<VariantRename>(name, rename_to, rename_all)
 }
@@ -357,11 +381,12 @@ impl TryToTokens for SimpleEnum<'_> {
                 })
                 .flat_map(|(variant, variant_rules)| {
                     let name = &*variant.ident.to_string();
-                    let mut variant_features = feature::parse_schema_features_with(&variant.attrs, |input| {
-                        Ok(parse_features!(input as Rename))
-                    })
-                    .ok()?
-                    .unwrap_or_default();
+                    let mut variant_features =
+                        feature::parse_schema_features_with(&variant.attrs, |input| {
+                            Ok(parse_features!(input as Rename))
+                        })
+                        .ok()?
+                        .unwrap_or_default();
                     let variant_name = rename_enum_variant(
                         name,
                         &mut variant_features,
@@ -406,12 +431,16 @@ fn regular_enum_to_tokens<T: self::enum_variant::Variant>(
                 Ok(tokens) => tokens,
                 Err(diag) => diag.emit_as_item_tokens(),
             },
-            SerdeEnumRepr::AdjacentlyTagged { tag, content } => AdjacentlyTaggedEnum::new(
-                enum_values
-                    .into_iter()
-                    .map(|variant| (Cow::Borrowed(tag.as_str()), Cow::Borrowed(content.as_str()), variant)),
-            )
-            .to_token_stream(),
+            SerdeEnumRepr::AdjacentlyTagged { tag, content } => {
+                AdjacentlyTaggedEnum::new(enum_values.into_iter().map(|variant| {
+                    (
+                        Cow::Borrowed(tag.as_str()),
+                        Cow::Borrowed(content.as_str()),
+                        variant,
+                    )
+                }))
+                .to_token_stream()
+            }
             // This should not be possible as serde should not let that happen
             SerdeEnumRepr::UnfinishedAdjacentlyTagged { .. } => panic!("Invalid serde enum repr"),
         },
@@ -473,27 +502,32 @@ impl ComplexEnum<'_> {
 
                 let example = pop_feature!(named_struct_features => Feature::Example(_));
 
-                Ok(Some(self::enum_variant::Variant::to_tokens(&ObjectVariant {
-                    name: variant_name.unwrap_or(Cow::Borrowed(&name)),
-                    title: title_features
-                        .first()
-                        .map(TryToTokens::try_to_token_stream)
-                        .transpose()?,
-                    example: example.as_ref().map(TryToTokens::try_to_token_stream).transpose()?,
-                    item: NamedStructSchema {
-                        struct_name: Cow::Borrowed(&*self.enum_name),
-                        attributes: &variant.attrs,
-                        description: None,
-                        rename_all: named_struct_features.pop_rename_all_feature(),
-                        features: Some(named_struct_features),
-                        fields: &named_fields.named,
-                        generics: None,
-                        name: None,
-                        aliases: None,
-                        inline: None,
-                    }
-                    .try_to_token_stream()?,
-                })))
+                Ok(Some(self::enum_variant::Variant::to_tokens(
+                    &ObjectVariant {
+                        name: variant_name.unwrap_or(Cow::Borrowed(&name)),
+                        title: title_features
+                            .first()
+                            .map(TryToTokens::try_to_token_stream)
+                            .transpose()?,
+                        example: example
+                            .as_ref()
+                            .map(TryToTokens::try_to_token_stream)
+                            .transpose()?,
+                        item: NamedStructSchema {
+                            struct_name: Cow::Borrowed(&*self.enum_name),
+                            attributes: &variant.attrs,
+                            description: None,
+                            rename_all: named_struct_features.pop_rename_all_feature(),
+                            features: Some(named_struct_features),
+                            fields: &named_fields.named,
+                            generics: None,
+                            name: None,
+                            aliases: None,
+                            inline: None,
+                        }
+                        .try_to_token_stream()?,
+                    },
+                )))
             }
             Fields::Unnamed(unnamed_fields) => {
                 let (title_features, mut unnamed_struct_features) = variant
@@ -517,36 +551,42 @@ impl ComplexEnum<'_> {
 
                 let example = pop_feature!(unnamed_struct_features => Feature::Example(_));
 
-                Ok(Some(self::enum_variant::Variant::to_tokens(&ObjectVariant {
-                    name: variant_name.unwrap_or(Cow::Borrowed(&name)),
-                    title: title_features
-                        .first()
-                        .map(TryToTokens::try_to_token_stream)
-                        .transpose()?,
-                    example: example.as_ref().map(TryToTokens::try_to_token_stream).transpose()?,
-                    item: UnnamedStructSchema {
-                        struct_name: Cow::Borrowed(&*self.enum_name),
-                        attributes: &variant.attrs,
-                        description: None,
-                        features: Some(unnamed_struct_features),
-                        fields: &unnamed_fields.unnamed,
-                        name: None,
-                        aliases: None,
-                        inline: None,
-                    }
-                    .try_to_token_stream()?,
-                })))
+                Ok(Some(self::enum_variant::Variant::to_tokens(
+                    &ObjectVariant {
+                        name: variant_name.unwrap_or(Cow::Borrowed(&name)),
+                        title: title_features
+                            .first()
+                            .map(TryToTokens::try_to_token_stream)
+                            .transpose()?,
+                        example: example
+                            .as_ref()
+                            .map(TryToTokens::try_to_token_stream)
+                            .transpose()?,
+                        item: UnnamedStructSchema {
+                            struct_name: Cow::Borrowed(&*self.enum_name),
+                            attributes: &variant.attrs,
+                            description: None,
+                            features: Some(unnamed_struct_features),
+                            fields: &unnamed_fields.unnamed,
+                            name: None,
+                            aliases: None,
+                            inline: None,
+                        }
+                        .try_to_token_stream()?,
+                    },
+                )))
             }
             Fields::Unit => {
-                let mut unit_features = feature::parse_schema_features_with(&variant.attrs, |input| {
-                    Ok(parse_features!(
-                        input as crate::feature::Title,
-                        RenameAll,
-                        Rename,
-                        Example
-                    ))
-                })?
-                .unwrap_or_default();
+                let mut unit_features =
+                    feature::parse_schema_features_with(&variant.attrs, |input| {
+                        Ok(parse_features!(
+                            input as crate::feature::Title,
+                            RenameAll,
+                            Rename,
+                            Example
+                        ))
+                    })?
+                    .unwrap_or_default();
 
                 if unit_features.is_skipped() {
                     return Ok(None);
@@ -562,12 +602,16 @@ impl ComplexEnum<'_> {
                 );
 
                 let example = pop_feature!(unit_features => Feature::Example(_));
-                let description = CommentAttributes::from_attributes(&variant.attrs).as_formatted_string();
-                let description = (!description.is_empty()).then(|| Feature::Description(description.into()));
+                let description =
+                    CommentAttributes::from_attributes(&variant.attrs).as_formatted_string();
+                let description =
+                    (!description.is_empty()).then(|| Feature::Description(description.into()));
 
                 // Unit variant is just simple enum with single variant.
                 let mut sev = Enum::new([SimpleEnumVariant {
-                    value: variant_name.unwrap_or(Cow::Borrowed(&name)).to_token_stream(),
+                    value: variant_name
+                        .unwrap_or(Cow::Borrowed(&name))
+                        .to_token_stream(),
                 }]);
                 if let Some(title) = title {
                     sev = sev.title(title.try_to_token_stream()?);
@@ -638,10 +682,11 @@ impl ComplexEnum<'_> {
                 .map(Some)
             }
             Fields::Unit => {
-                let mut unit_features = feature::parse_schema_features_with(&variant.attrs, |input| {
-                    Ok(parse_features!(input as crate::feature::Title))
-                })?
-                .unwrap_or_default();
+                let mut unit_features =
+                    feature::parse_schema_features_with(&variant.attrs, |input| {
+                        Ok(parse_features!(input as crate::feature::Title))
+                    })?
+                    .unwrap_or_default();
 
                 if unit_features.is_skipped() {
                     return Ok(None);
@@ -649,7 +694,9 @@ impl ComplexEnum<'_> {
 
                 let title = pop_feature!(unit_features => Feature::Title(_));
 
-                UntaggedEnum::with_title(title).try_to_token_stream().map(Some)
+                UntaggedEnum::with_title(title)
+                    .try_to_token_stream()
+                    .map(Some)
             }
         }
     }
@@ -706,7 +753,9 @@ impl ComplexEnum<'_> {
                     .transpose()?;
 
                 let variant_name_tokens = Enum::new([SimpleEnumVariant {
-                    value: variant_name.unwrap_or(Cow::Borrowed(&name)).to_token_stream(),
+                    value: variant_name
+                        .unwrap_or(Cow::Borrowed(&name))
+                        .to_token_stream(),
                 }]);
                 Ok(Some(quote! {
                     #named_enum
@@ -753,7 +802,9 @@ impl ComplexEnum<'_> {
                         .map(TryToTokens::try_to_token_stream)
                         .transpose()?;
                     let variant_name_tokens = Enum::new([SimpleEnumVariant {
-                        value: variant_name.unwrap_or(Cow::Borrowed(&name)).to_token_stream(),
+                        value: variant_name
+                            .unwrap_or(Cow::Borrowed(&name))
+                            .to_token_stream(),
                     }]);
 
                     let is_reference = unnamed_fields.unnamed.iter().any(|field| {
@@ -791,10 +842,11 @@ impl ComplexEnum<'_> {
                 }
             }
             Fields::Unit => {
-                let mut unit_features = feature::parse_schema_features_with(&variant.attrs, |input| {
-                    Ok(parse_features!(input as crate::feature::Title, Rename))
-                })?
-                .unwrap_or_default();
+                let mut unit_features =
+                    feature::parse_schema_features_with(&variant.attrs, |input| {
+                        Ok(parse_features!(input as crate::feature::Title, Rename))
+                    })?
+                    .unwrap_or_default();
 
                 if unit_features.is_skipped() {
                     return Ok(None);
@@ -814,7 +866,9 @@ impl ComplexEnum<'_> {
 
                 // Unit variant is just simple enum with single variant.
                 let variant_tokens = Enum::new([SimpleEnumVariant {
-                    value: variant_name.unwrap_or(Cow::Borrowed(&name)).to_token_stream(),
+                    value: variant_name
+                        .unwrap_or(Cow::Borrowed(&name))
+                        .to_token_stream(),
                 }]);
 
                 Ok(Some(quote! {
@@ -874,10 +928,15 @@ impl ComplexEnum<'_> {
                     inline: None,
                 }
                 .try_to_token_stream()?;
-                let title = title_features.first().map(|s| s.try_to_token_stream()).transpose()?;
+                let title = title_features
+                    .first()
+                    .map(|s| s.try_to_token_stream())
+                    .transpose()?;
 
                 let variant_name_tokens = Enum::new([SimpleEnumVariant {
-                    value: variant_name.unwrap_or(Cow::Borrowed(&name)).to_token_stream(),
+                    value: variant_name
+                        .unwrap_or(Cow::Borrowed(&name))
+                        .to_token_stream(),
                 }]);
                 Ok(Some(quote! {
                     #oapi::oapi::schema::Object::new()
@@ -928,7 +987,9 @@ impl ComplexEnum<'_> {
                         .transpose()?
                         .map(|title| quote! { .title(#title)});
                     let variant_name_tokens = Enum::new([SimpleEnumVariant {
-                        value: variant_name.unwrap_or(Cow::Borrowed(&name)).to_token_stream(),
+                        value: variant_name
+                            .unwrap_or(Cow::Borrowed(&name))
+                            .to_token_stream(),
                     }]);
 
                     Ok(Some(quote! {
@@ -950,10 +1011,11 @@ impl ComplexEnum<'_> {
             }
             Fields::Unit => {
                 // In this case `content` is simply ignored - there is nothing to put in it.
-                let mut unit_features = feature::parse_schema_features_with(&variant.attrs, |input| {
-                    Ok(parse_features!(input as crate::feature::Title, Rename))
-                })?
-                .unwrap_or_default();
+                let mut unit_features =
+                    feature::parse_schema_features_with(&variant.attrs, |input| {
+                        Ok(parse_features!(input as crate::feature::Title, Rename))
+                    })?
+                    .unwrap_or_default();
 
                 if unit_features.is_skipped() {
                     return Ok(None);
@@ -973,7 +1035,9 @@ impl ComplexEnum<'_> {
 
                 // Unit variant is just simple enum with single variant.
                 let variant_tokens = Enum::new([SimpleEnumVariant {
-                    value: variant_name.unwrap_or(Cow::Borrowed(&name)).to_token_stream(),
+                    value: variant_name
+                        .unwrap_or(Cow::Borrowed(&name))
+                        .to_token_stream(),
                 }]);
 
                 Ok(Some(quote! {
@@ -997,7 +1061,8 @@ impl TryToTokens for ComplexEnum<'_> {
             .map(|rules| rules.enum_repr.clone())
             .unwrap_or_default();
         let tag = match &enum_repr {
-            SerdeEnumRepr::AdjacentlyTagged { tag, .. } | SerdeEnumRepr::InternallyTagged { tag } => Some(tag),
+            SerdeEnumRepr::AdjacentlyTagged { tag, .. }
+            | SerdeEnumRepr::InternallyTagged { tag } => Some(tag),
             SerdeEnumRepr::ExternallyTagged
             | SerdeEnumRepr::Untagged
             | SerdeEnumRepr::UnfinishedAdjacentlyTagged { .. } => None,
@@ -1033,15 +1098,16 @@ impl TryToTokens for ComplexEnum<'_> {
                         &self.rename_all,
                     ),
                     SerdeEnumRepr::Untagged => self.untagged_variant_tokens(variant),
-                    SerdeEnumRepr::AdjacentlyTagged { tag, content } => self.adjacently_tagged_variant_tokens(
-                        tag,
-                        content,
-                        Cow::Borrowed(variant_name),
-                        variant,
-                        &variant_serde_rules,
-                        &container_rules,
-                        &self.rename_all,
-                    ),
+                    SerdeEnumRepr::AdjacentlyTagged { tag, content } => self
+                        .adjacently_tagged_variant_tokens(
+                            tag,
+                            content,
+                            Cow::Borrowed(variant_name),
+                            variant,
+                            &variant_serde_rules,
+                            &container_rules,
+                            &self.rename_all,
+                        ),
                     SerdeEnumRepr::UnfinishedAdjacentlyTagged { .. } => {
                         unreachable!("Serde should not have parsed an UnfinishedAdjacentlyTagged")
                     }
@@ -1052,7 +1118,8 @@ impl TryToTokens for ComplexEnum<'_> {
             .flatten()
             .collect::<CustomEnum<'_, TokenStream>>();
         if let Some(tag) = tag {
-            ts.discriminator(Cow::Borrowed(tag.as_str())).to_tokens(tokens);
+            ts.discriminator(Cow::Borrowed(tag.as_str()))
+                .to_tokens(tokens);
         } else {
             ts.to_tokens(tokens);
         }
diff --git a/crates/oapi-macros/src/schema/enum_variant.rs b/crates/oapi-macros/src/schema/enum_variant.rs
index 3c013b6b9..7dc409bf6 100644
--- a/crates/oapi-macros/src/schema/enum_variant.rs
+++ b/crates/oapi-macros/src/schema/enum_variant.rs
@@ -270,7 +270,11 @@ impl UntaggedEnum {
 impl TryToTokens for UntaggedEnum {
     fn try_to_tokens(&self, tokens: &mut TokenStream) -> DiagResult<()> {
         let oapi = crate::oapi_crate();
-        let title = self.title.as_ref().map(|f| f.try_to_token_stream()).transpose()?;
+        let title = self
+            .title
+            .as_ref()
+            .map(|f| f.try_to_token_stream())
+            .transpose()?;
 
         tokens.extend(quote! {
             #oapi::oapi::schema::Object::new()
@@ -289,7 +293,9 @@ pub(crate) struct AdjacentlyTaggedEnum<T: Variant> {
 }
 
 impl<V: Variant> AdjacentlyTaggedEnum<V> {
-    pub(crate) fn new<'t, I: IntoIterator<Item = (Cow<'t, str>, Cow<'t, str>, V)>>(items: I) -> Self {
+    pub(crate) fn new<'t, I: IntoIterator<Item = (Cow<'t, str>, Cow<'t, str>, V)>>(
+        items: I,
+    ) -> Self {
         items.into_iter().collect()
     }
 }
diff --git a/crates/oapi-macros/src/schema/feature.rs b/crates/oapi-macros/src/schema/feature.rs
index 00cc597fc..89791dcff 100644
--- a/crates/oapi-macros/src/schema/feature.rs
+++ b/crates/oapi-macros/src/schema/feature.rs
@@ -2,10 +2,11 @@ use syn::parse::{Parse, ParseBuffer, ParseStream};
 use syn::Attribute;
 
 use crate::feature::{
-    impl_into_inner, impl_merge, parse_features, AdditionalProperties, Aliases, Bound, ContentEncoding,
-    ContentMediaType, Default, Deprecated, Description, Example, Examples, ExclusiveMaximum, ExclusiveMinimum, Feature,
-    Format, Inline, MaxItems, MaxLength, MaxProperties, Maximum, Merge, MinItems, MinLength, MinProperties, Minimum,
-    MultipleOf, Name, Nullable, Pattern, ReadOnly, Rename, RenameAll, Required, SchemaWith, Skip, SkipBound, Title,
+    impl_into_inner, impl_merge, parse_features, AdditionalProperties, Aliases, Bound,
+    ContentEncoding, ContentMediaType, Default, Deprecated, Description, Example, Examples,
+    ExclusiveMaximum, ExclusiveMinimum, Feature, Format, Inline, MaxItems, MaxLength,
+    MaxProperties, Maximum, Merge, MinItems, MinLength, MinProperties, Minimum, MultipleOf, Name,
+    Nullable, Pattern, ReadOnly, Rename, RenameAll, Required, SchemaWith, Skip, SkipBound, Title,
     ValueType, WriteOnly, XmlAttr,
 };
 use crate::{attribute, DiagResult, Diagnostic, IntoInner};
@@ -222,7 +223,9 @@ impl_merge!(
     EnumUnnamedFieldVariantFeatures
 );
 
-pub(crate) fn parse_schema_features<T: Sized + Parse + Merge<T>>(attributes: &[Attribute]) -> DiagResult<Option<T>> {
+pub(crate) fn parse_schema_features<T: Sized + Parse + Merge<T>>(
+    attributes: &[Attribute],
+) -> DiagResult<Option<T>> {
     Ok(attributes
         .iter()
         .filter(|attribute| attribute.path().is_ident("salvo"))
diff --git a/crates/oapi-macros/src/schema/mod.rs b/crates/oapi-macros/src/schema/mod.rs
index 822cd7394..b8c3f5ca8 100644
--- a/crates/oapi-macros/src/schema/mod.rs
+++ b/crates/oapi-macros/src/schema/mod.rs
@@ -11,7 +11,10 @@ use proc_macro2::{Ident, TokenStream};
 use quote::{quote, ToTokens};
 use syn::punctuated::Punctuated;
 use syn::token::Comma;
-use syn::{parse_quote, Attribute, Data, DeriveInput, Fields, FieldsNamed, FieldsUnnamed, Generics, Visibility};
+use syn::{
+    parse_quote, Attribute, Data, DeriveInput, Fields, FieldsNamed, FieldsUnnamed, Generics,
+    Visibility,
+};
 
 pub(crate) use self::{
     enum_schemas::*,
@@ -23,7 +26,8 @@ pub(crate) use self::{
 
 use super::{ComponentSchema, FieldRename, VariantRename};
 use crate::feature::{
-    pop_feature, pop_feature_as_inner, Alias, Bound, Description, Feature, FeaturesExt, Inline, Name, SkipBound,
+    pop_feature, pop_feature_as_inner, Alias, Bound, Description, Feature, FeaturesExt, Inline,
+    Name, SkipBound,
 };
 use crate::schema::feature::EnumFeatures;
 use crate::serde_util::SerdeValue;
@@ -116,7 +120,11 @@ impl TryToTokens for ToSchema<'_> {
         if skip_bound != Some(SkipBound(true)) {
             generics = match bound {
                 Some(predicates) => bound::with_where_predicates(&generics, &predicates),
-                None => bound::with_bound(self.data, &generics, parse_quote!(#oapi::oapi::ToSchema + 'static)),
+                None => bound::with_bound(
+                    self.data,
+                    &generics,
+                    parse_quote!(#oapi::oapi::ToSchema + 'static),
+                ),
             };
         }
 
@@ -190,11 +198,14 @@ impl<'a> SchemaVariant<'a> {
             Data::Struct(content) => match &content.fields {
                 Fields::Unnamed(fields) => {
                     let FieldsUnnamed { unnamed, .. } = fields;
-                    let mut unnamed_features = attributes.parse_features::<UnnamedFieldStructFeatures>()?.into_inner();
+                    let mut unnamed_features = attributes
+                        .parse_features::<UnnamedFieldStructFeatures>()?
+                        .into_inner();
 
                     let name = pop_feature_as_inner!(unnamed_features => Feature::Name(_v));
                     let aliases = pop_feature_as_inner!(unnamed_features => Feature::Aliases(_v));
-                    if generics.type_params().count() == 0 && !aliases.as_ref().map(|a| a.0.is_empty()).unwrap_or(true)
+                    if generics.type_params().count() == 0
+                        && !aliases.as_ref().map(|a| a.0.is_empty()).unwrap_or(true)
                     {
                         return Err(Diagnostic::spanned(
                             ident.span(),
@@ -204,7 +215,8 @@ impl<'a> SchemaVariant<'a> {
                     }
 
                     let inline = pop_feature_as_inner!(unnamed_features => Feature::Inline(_v));
-                    let description = pop_feature!(unnamed_features => Feature::Description(_)).into_inner();
+                    let description =
+                        pop_feature!(unnamed_features => Feature::Description(_)).into_inner();
                     Ok(Self::Unnamed(UnnamedStructSchema {
                         struct_name: Cow::Owned(ident.to_string()),
                         attributes,
@@ -218,13 +230,16 @@ impl<'a> SchemaVariant<'a> {
                 }
                 Fields::Named(fields) => {
                     let FieldsNamed { named, .. } = fields;
-                    let mut named_features: Option<Vec<Feature>> =
-                        attributes.parse_features::<NamedFieldStructFeatures>()?.into_inner();
+                    let mut named_features: Option<Vec<Feature>> = attributes
+                        .parse_features::<NamedFieldStructFeatures>()?
+                        .into_inner();
 
                     let generic_count = generics.type_params().count();
                     let name = pop_feature_as_inner!(named_features => Feature::Name(_v));
                     let aliases = pop_feature_as_inner!(named_features => Feature::Aliases(_v));
-                    if generic_count == 0 && !aliases.as_ref().map(|a| a.0.is_empty()).unwrap_or(true) {
+                    if generic_count == 0
+                        && !aliases.as_ref().map(|a| a.0.is_empty()).unwrap_or(true)
+                    {
                         return Err(Diagnostic::spanned(
                             ident.span(),
                             DiagLevel::Error,
@@ -233,7 +248,8 @@ impl<'a> SchemaVariant<'a> {
                     }
 
                     let inline = pop_feature_as_inner!(named_features => Feature::Inline(_v));
-                    let description = pop_feature!(named_features => Feature::Description(_)).into_inner();
+                    let description =
+                        pop_feature!(named_features => Feature::Description(_)).into_inner();
                     Ok(Self::Named(NamedStructSchema {
                         struct_name: Cow::Owned(ident.to_string()),
                         attributes,
@@ -250,7 +266,8 @@ impl<'a> SchemaVariant<'a> {
                 Fields::Unit => Ok(Self::Unit(UnitStructVariant)),
             },
             Data::Enum(content) => {
-                let mut enum_features: Option<Vec<Feature>> = attributes.parse_features::<EnumFeatures>()?.into_inner();
+                let mut enum_features: Option<Vec<Feature>> =
+                    attributes.parse_features::<EnumFeatures>()?.into_inner();
                 let aliases = pop_feature_as_inner!(enum_features => Feature::Aliases(_v));
                 Ok(Self::Enum(EnumSchema::new(
                     Cow::Owned(ident.to_string()),
diff --git a/crates/oapi-macros/src/schema/struct_schemas.rs b/crates/oapi-macros/src/schema/struct_schemas.rs
index e577304d3..a299555bb 100644
--- a/crates/oapi-macros/src/schema/struct_schemas.rs
+++ b/crates/oapi-macros/src/schema/struct_schemas.rs
@@ -8,13 +8,14 @@ use syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Field, Generics,
 use crate::component::{ComponentDescription, ComponentSchemaProps};
 use crate::doc_comment::CommentAttributes;
 use crate::feature::{
-    parse_features, pop_feature, pop_feature_as_inner, Alias, Bound, Feature, FeaturesExt, IsSkipped, Name, RenameAll,
-    SkipBound, TryToTokensExt,
+    parse_features, pop_feature, pop_feature_as_inner, Alias, Bound, Feature, FeaturesExt,
+    IsSkipped, Name, RenameAll, SkipBound, TryToTokensExt,
 };
 use crate::schema::{Description, Inline};
 use crate::type_tree::TypeTree;
 use crate::{
-    serde_util, Deprecated, DiagLevel, DiagResult, Diagnostic, IntoInner, SerdeContainer, SerdeValue, TryToTokens,
+    serde_util, Deprecated, DiagLevel, DiagResult, Diagnostic, IntoInner, SerdeContainer,
+    SerdeValue, TryToTokens,
 };
 
 use super::{
@@ -59,34 +60,48 @@ impl NamedStructSchema<'_> {
     ) -> DiagResult<NamedStructFieldOptions<'_>> {
         let type_tree = &mut TypeTree::from_type(&field.ty)?;
 
-        let mut field_features = field.attrs.parse_features::<NamedFieldFeatures>()?.into_inner();
+        let mut field_features = field
+            .attrs
+            .parse_features::<NamedFieldFeatures>()?
+            .into_inner();
 
         let schema_default = self
             .features
             .as_ref()
             .map(|features| features.iter().any(|f| matches!(f, Feature::Default(_))))
             .unwrap_or(false);
-        let serde_default = container_rules.as_ref().map(|rules| rules.is_default).unwrap_or(false);
+        let serde_default = container_rules
+            .as_ref()
+            .map(|rules| rules.is_default)
+            .unwrap_or(false);
 
         if schema_default || serde_default {
             let features_inner = field_features.get_or_insert(vec![]);
-            if !features_inner.iter().any(|f| matches!(f, Feature::Default(_))) {
-                let field_ident = field.ident.as_ref().expect("field ident shoule be exist").to_owned();
+            if !features_inner
+                .iter()
+                .any(|f| matches!(f, Feature::Default(_)))
+            {
+                let field_ident = field
+                    .ident
+                    .as_ref()
+                    .expect("field ident shoule be exist")
+                    .to_owned();
                 let struct_ident = format_ident!("{}", &self.struct_name);
-                features_inner.push(Feature::Default(crate::feature::Default::new_default_trait(
-                    struct_ident,
-                    field_ident.into(),
-                )));
+                features_inner.push(Feature::Default(
+                    crate::feature::Default::new_default_trait(struct_ident, field_ident.into()),
+                ));
             }
         }
 
-        let rename_field = pop_feature!(field_features => Feature::Rename(_)).and_then(|feature| match feature {
-            Feature::Rename(rename) => Some(Cow::Owned(rename.into_value())),
-            _ => None,
-        });
+        let rename_field =
+            pop_feature!(field_features => Feature::Rename(_)).and_then(|feature| match feature {
+                Feature::Rename(rename) => Some(Cow::Owned(rename.into_value())),
+                _ => None,
+            });
 
         let deprecated = crate::get_deprecated(&field.attrs).or_else(|| {
-            pop_feature!(field_features => Feature::Deprecated(_)).and_then(|feature| match feature {
+            pop_feature!(field_features => Feature::Deprecated(_)).and_then(|feature| match feature
+            {
                 Feature::Deprecated(_) => Some(Deprecated::True),
                 _ => None,
             })
@@ -165,7 +180,11 @@ impl TryToTokens for NamedStructSchema<'_> {
 
         let mut object_tokens = quote! { #oapi::oapi::Object::new() };
         for (field, field_rule) in field_values {
-            let mut field_name = &*field.ident.as_ref().expect("field ident shoule be exists").to_string();
+            let mut field_name = &*field
+                .ident
+                .as_ref()
+                .expect("field ident shoule be exists")
+                .to_string();
 
             if field_name.starts_with("r#") {
                 field_name = &field_name[2..];
@@ -184,17 +203,22 @@ impl TryToTokens for NamedStructSchema<'_> {
             let rename_all = container_rules
                 .as_ref()
                 .and_then(|container_rule| container_rule.rename_all.as_ref())
-                .or_else(|| self.rename_all.as_ref().map(|rename_all| rename_all.as_rename_rule()));
+                .or_else(|| {
+                    self.rename_all
+                        .as_ref()
+                        .map(|rename_all| rename_all.as_rename_rule())
+                });
 
-            let name =
-                crate::rename::<FieldRename>(field_name, rename_to, rename_all).unwrap_or(Cow::Borrowed(field_name));
+            let name = crate::rename::<FieldRename>(field_name, rename_to, rename_all)
+                .unwrap_or(Cow::Borrowed(field_name));
 
             let property = property.try_to_token_stream()?;
             object_tokens.extend(quote! {
                 .property(#name, #property)
             });
 
-            let component_required = !is_option && crate::is_required(field_rule.as_ref(), container_rules.as_ref());
+            let component_required =
+                !is_option && crate::is_required(field_rule.as_ref(), container_rules.as_ref());
             let required = match (required, component_required) {
                 (Some(required), _) => required.is_true(),
                 (None, component_required) => component_required,
@@ -232,7 +256,8 @@ impl TryToTokens for NamedStructSchema<'_> {
                     Property::FlattenedMap(_) => match flattened_map_field {
                         None => {
                             let property = property.try_to_token_stream()?;
-                            object_tokens.extend(quote! { .additional_properties(Some(#property)) });
+                            object_tokens
+                                .extend(quote! { .additional_properties(Some(#property)) });
                             flattened_map_field = Some(field);
                         }
                         Some(flattened_map_field) => {
@@ -362,13 +387,14 @@ impl TryToTokens for UnnamedStructSchema<'_> {
 
                     features.extend(inline);
 
-                    if pop_feature!(features => Feature::Default(crate::feature::Default(None))).is_some() {
+                    if pop_feature!(features => Feature::Default(crate::feature::Default(None)))
+                        .is_some()
+                    {
                         let struct_ident = format_ident!("{}", &self.struct_name);
                         let index: syn::Index = 0.into();
-                        features.push(Feature::Default(crate::feature::Default::new_default_trait(
-                            struct_ident,
-                            index.into(),
-                        )));
+                        features.push(Feature::Default(
+                            crate::feature::Default::new_default_trait(struct_ident, index.into()),
+                        ));
                     }
                 }
             }
diff --git a/crates/oapi-macros/src/schema/xml.rs b/crates/oapi-macros/src/schema/xml.rs
index 218c352eb..fbde49803 100644
--- a/crates/oapi-macros/src/schema/xml.rs
+++ b/crates/oapi-macros/src/schema/xml.rs
@@ -37,11 +37,18 @@ impl Parse for XmlAttr {
             let attr_name = &*attribute.to_string();
 
             match attr_name {
-                "name" => xml.name = Some(parse_utils::parse_next(input, || input.parse::<LitStr>())?.value()),
+                "name" => {
+                    xml.name =
+                        Some(parse_utils::parse_next(input, || input.parse::<LitStr>())?.value())
+                }
                 "namespace" => {
-                    xml.namespace = Some(parse_utils::parse_next(input, || input.parse::<LitStr>())?.value())
+                    xml.namespace =
+                        Some(parse_utils::parse_next(input, || input.parse::<LitStr>())?.value())
+                }
+                "prefix" => {
+                    xml.prefix =
+                        Some(parse_utils::parse_next(input, || input.parse::<LitStr>())?.value())
                 }
-                "prefix" => xml.prefix = Some(parse_utils::parse_next(input, || input.parse::<LitStr>())?.value()),
                 "attribute" => xml.is_attribute = parse_utils::parse_bool_or_true(input)?,
                 "wrapped" => {
                     // wrapped or wrapped(name = "wrap_name")
@@ -50,7 +57,10 @@ impl Parse for XmlAttr {
                         parenthesized!(group in input);
 
                         let wrapped_attribute = group.parse::<Ident>().map_err(|error| {
-                            Error::new(error.span(), format!("unexpected attribute, expected: name, {error}"))
+                            Error::new(
+                                error.span(),
+                                format!("unexpected attribute, expected: name, {error}"),
+                            )
                         })?;
                         if wrapped_attribute != "name" {
                             return Err(Error::new(
diff --git a/crates/oapi-macros/src/schema_type.rs b/crates/oapi-macros/src/schema_type.rs
index c54c7de1d..770877f98 100644
--- a/crates/oapi-macros/src/schema_type.rs
+++ b/crates/oapi-macros/src/schema_type.rs
@@ -97,7 +97,10 @@ impl SchemaType<'_> {
 
             #[cfg(feature = "chrono")]
             if !primitive {
-                primitive = matches!(name, "DateTime" | "NaiveDate" | "Duration" | "NaiveDateTime");
+                primitive = matches!(
+                    name,
+                    "DateTime" | "NaiveDate" | "Duration" | "NaiveDateTime"
+                );
             }
             #[cfg(any(feature = "decimal", feature = "decimal-float"))]
             if !primitive {
@@ -117,7 +120,10 @@ impl SchemaType<'_> {
             }
             #[cfg(feature = "time")]
             if !primitive {
-                primitive = matches!(name, "Date" | "PrimitiveDateTime" | "OffsetDateTime" | "Duration");
+                primitive = matches!(
+                    name,
+                    "Date" | "PrimitiveDateTime" | "OffsetDateTime" | "Duration"
+                );
             }
 
             primitive
@@ -127,7 +133,17 @@ impl SchemaType<'_> {
     pub(crate) fn is_integer(&self) -> bool {
         matches!(
             &*self.last_segment_to_string(),
-            "i8" | "i16" | "i32" | "i64" | "i128" | "isize" | "u8" | "u16" | "u32" | "u64" | "u128" | "usize"
+            "i8" | "i16"
+                | "i32"
+                | "i64"
+                | "i128"
+                | "isize"
+                | "u8"
+                | "u16"
+                | "u32"
+                | "u64"
+                | "u128"
+                | "usize"
         )
     }
 
@@ -209,18 +225,25 @@ impl TryToTokens for SchemaType<'_> {
         }
 
         match name {
-            "String" | "str" | "char" => schema_type_tokens(tokens, oapi, SchemaTypeInner::String, self.nullable),
+            "String" | "str" | "char" => {
+                schema_type_tokens(tokens, oapi, SchemaTypeInner::String, self.nullable)
+            }
             "bool" => schema_type_tokens(tokens, oapi, SchemaTypeInner::Boolean, self.nullable),
-            "i8" | "i16" | "i32" | "i64" | "i128" | "isize" | "u8" | "u16" | "u32" | "u64" | "u128" | "usize" => {
+            "i8" | "i16" | "i32" | "i64" | "i128" | "isize" | "u8" | "u16" | "u32" | "u64"
+            | "u128" | "usize" => {
                 schema_type_tokens(tokens, oapi, SchemaTypeInner::Integer, self.nullable)
             }
-            "f32" | "f64" => schema_type_tokens(tokens, oapi, SchemaTypeInner::Number, self.nullable),
+            "f32" | "f64" => {
+                schema_type_tokens(tokens, oapi, SchemaTypeInner::Number, self.nullable)
+            }
             #[cfg(feature = "chrono")]
             "DateTime" | "NaiveDateTime" | "NaiveDate" | "NaiveTime" => {
                 schema_type_tokens(tokens, oapi, SchemaTypeInner::String, self.nullable)
             }
             #[cfg(any(feature = "chrono", feature = "time"))]
-            "Date" | "Duration" => schema_type_tokens(tokens, oapi, SchemaTypeInner::String, self.nullable),
+            "Date" | "Duration" => {
+                schema_type_tokens(tokens, oapi, SchemaTypeInner::String, self.nullable)
+            }
             #[cfg(all(feature = "decimal", feature = "decimal-float"))]
             "Decimal" => schema_type_tokens(tokens, oapi, SchemaTypeInner::String, self.nullable),
             #[cfg(all(feature = "decimal", not(feature = "decimal-float")))]
@@ -446,8 +469,8 @@ pub(crate) enum Variant {
 impl Parse for Variant {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         const FORMATS: [&str; 12] = [
-            "Int32", "Int64", "Float", "Double", "Byte", "Binary", "Date", "DateTime", "Password", "Ulid", "Uuid",
-            "Url",
+            "Int32", "Int64", "Float", "Double", "Byte", "Binary", "Date", "DateTime", "Password",
+            "Ulid", "Uuid", "Url",
         ];
         let excluded_format: &[&str] = &[
             #[cfg(not(feature = "url"))]
diff --git a/crates/oapi-macros/src/shared.rs b/crates/oapi-macros/src/shared.rs
index ec82afa95..6a579b1f2 100644
--- a/crates/oapi-macros/src/shared.rs
+++ b/crates/oapi-macros/src/shared.rs
@@ -8,7 +8,10 @@ use quote::{quote, ToTokens, TokenStreamExt};
 use regex::Regex;
 use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
-use syn::{Attribute, ExprPath, FnArg, Ident, Lit, LitStr, Member, PatType, Receiver, Token, Type, TypePath};
+use syn::{
+    Attribute, ExprPath, FnArg, Ident, Lit, LitStr, Member, PatType, Receiver, Token, Type,
+    TypePath,
+};
 
 use crate::{feature, parse_utils, RenameRule, SerdeContainer, SerdeValue};
 
@@ -58,7 +61,12 @@ pub(crate) fn parse_input_type(input: &FnArg) -> InputType {
                 // such as:
                 // `::std::vec::Vec` is `Vec`
                 // `Vec` is `Vec`
-                let ident = &nty.path.segments.last().expect("path segments is empty").ident;
+                let ident = &nty
+                    .path
+                    .segments
+                    .last()
+                    .expect("path segments is empty")
+                    .ident;
                 if ident == "Request" {
                     InputType::Request(p)
                 } else if ident == "Response" {
@@ -106,15 +114,27 @@ pub(crate) type DiagResult<T> = Result<T, Diagnostic>;
 
 /// Check whether either serde `container_rule` or `field_rule` has _`default`_ attribute set.
 #[inline]
-pub(crate) fn is_default(container_rules: &Option<&SerdeContainer>, field_rule: &Option<&SerdeValue>) -> bool {
-    container_rules.as_ref().map(|rule| rule.is_default).unwrap_or(false)
-        || field_rule.as_ref().map(|rule| rule.is_default).unwrap_or(false)
+pub(crate) fn is_default(
+    container_rules: &Option<&SerdeContainer>,
+    field_rule: &Option<&SerdeValue>,
+) -> bool {
+    container_rules
+        .as_ref()
+        .map(|rule| rule.is_default)
+        .unwrap_or(false)
+        || field_rule
+            .as_ref()
+            .map(|rule| rule.is_default)
+            .unwrap_or(false)
 }
 
 /// Find `#[deprecated]` attribute from given attributes. Typically derive type attributes
 /// or field attributes of struct.
 pub(crate) fn get_deprecated(attributs: &[Attribute]) -> Option<crate::Deprecated> {
-    if attributs.iter().any(|attr| attr.path().is_ident("deprecated")) {
+    if attributs
+        .iter()
+        .any(|attr| attr.path().is_ident("deprecated"))
+    {
         Some(Deprecated::True)
     } else {
         None
@@ -125,8 +145,13 @@ pub(crate) fn get_deprecated(attributs: &[Attribute]) -> Option<crate::Deprecate
 ///
 /// * If field has not serde's `skip_serializing_if`
 /// * Field is not default
-pub(crate) fn is_required(field_rule: Option<&SerdeValue>, container_rules: Option<&SerdeContainer>) -> bool {
-    !field_rule.map(|rule| rule.skip_serializing_if).unwrap_or(false)
+pub(crate) fn is_required(
+    field_rule: Option<&SerdeValue>,
+    container_rules: Option<&SerdeContainer>,
+) -> bool {
+    !field_rule
+        .map(|rule| rule.skip_serializing_if)
+        .unwrap_or(false)
         && !field_rule.map(|rule| rule.double_option).unwrap_or(false)
         && !is_default(&container_rules, &field_rule)
 }
@@ -265,9 +290,9 @@ impl Parse for ExternalDocs {
         let mut external_docs = ExternalDocs::default();
 
         while !input.is_empty() {
-            let ident = input
-                .parse::<Ident>()
-                .map_err(|error| syn::Error::new(error.span(), format!("{EXPECTED_ATTRIBUTE}, {error}")))?;
+            let ident = input.parse::<Ident>().map_err(|error| {
+                syn::Error::new(error.span(), format!("{EXPECTED_ATTRIBUTE}, {error}"))
+            })?;
             let attr_name = &*ident.to_string();
 
             match attr_name {
@@ -311,7 +336,10 @@ impl ToTokens for ExternalDocs {
 pub(crate) enum AnyValue {
     String(TokenStream),
     Json(TokenStream),
-    DefaultTrait { struct_ident: Ident, field_ident: Member },
+    DefaultTrait {
+        struct_ident: Ident,
+        field_ident: Member,
+    },
 }
 
 impl AnyValue {
@@ -342,7 +370,10 @@ impl AnyValue {
                 Ok(AnyValue::Json(json))
             } else {
                 let method = input.parse::<ExprPath>().map_err(|error| {
-                    syn::Error::new(error.span(), "expected literal value, json!(...) or method reference")
+                    syn::Error::new(
+                        error.span(),
+                        "expected literal value, json!(...) or method reference",
+                    )
                 })?;
 
                 Ok(AnyValue::Json(quote! { #method() }))
diff --git a/crates/oapi-macros/src/type_tree.rs b/crates/oapi-macros/src/type_tree.rs
index 6bb80094f..14883f041 100644
--- a/crates/oapi-macros/src/type_tree.rs
+++ b/crates/oapi-macros/src/type_tree.rs
@@ -101,7 +101,9 @@ impl<'t> TypeTree<'t> {
         }
     }
 
-    fn convert_types(paths: Vec<TypeTreeValue<'t>>) -> DiagResult<impl Iterator<Item = TypeTree<'t>>> {
+    fn convert_types(
+        paths: Vec<TypeTreeValue<'t>>,
+    ) -> DiagResult<impl Iterator<Item = TypeTree<'t>>> {
         paths
             .into_iter()
             .map(|value| {
@@ -155,7 +157,10 @@ impl<'t> TypeTree<'t> {
     }
 
     // Only when type is a generic type we get to this function.
-    fn resolve_schema_type(path: &'t Path, last_segment: &'t PathSegment) -> DiagResult<TypeTree<'t>> {
+    fn resolve_schema_type(
+        path: &'t Path,
+        last_segment: &'t PathSegment,
+    ) -> DiagResult<TypeTree<'t>> {
         if last_segment.arguments.is_empty() {
             return Err(Diagnostic::spanned(
                 last_segment.ident.span(),
@@ -169,18 +174,24 @@ impl<'t> TypeTree<'t> {
         let mut generic_types = match &last_segment.arguments {
             PathArguments::AngleBracketed(angle_bracketed_args) => {
                 // if all type arguments are lifetimes we ignore the generic type
-                if angle_bracketed_args
-                    .args
-                    .iter()
-                    .all(|arg| matches!(arg, GenericArgument::Lifetime(_) | GenericArgument::Const(_)))
-                {
+                if angle_bracketed_args.args.iter().all(|arg| {
+                    matches!(
+                        arg,
+                        GenericArgument::Lifetime(_) | GenericArgument::Const(_)
+                    )
+                }) {
                     None
                 } else {
                     Some(
                         angle_bracketed_args
                             .args
                             .iter()
-                            .filter(|arg| !matches!(arg, GenericArgument::Lifetime(_) | GenericArgument::Const(_)))
+                            .filter(|arg| {
+                                !matches!(
+                                    arg,
+                                    GenericArgument::Lifetime(_) | GenericArgument::Const(_)
+                                )
+                            })
                             .map(|arg| match arg {
                                 GenericArgument::Type(arg) => Ok(arg),
                                 _ => Err(Diagnostic::spanned(
diff --git a/crates/oapi/src/endpoint.rs b/crates/oapi/src/endpoint.rs
index e9f45b502..3531b68d9 100644
--- a/crates/oapi/src/endpoint.rs
+++ b/crates/oapi/src/endpoint.rs
@@ -18,7 +18,10 @@ pub struct Endpoint {
 impl Endpoint {
     /// Create new `Endpoint` with given operation and components.
     pub fn new(operation: Operation, components: Components) -> Self {
-        Self { operation, components }
+        Self {
+            operation,
+            components,
+        }
     }
 }
 
@@ -39,7 +42,9 @@ where
 {
     #[inline]
     fn register(components: &mut Components, operation: &mut Operation) {
-        operation.responses.insert("200", Self::to_response(components));
+        operation
+            .responses
+            .insert("200", Self::to_response(components));
     }
 }
 impl<T, E> EndpointOutRegister for Result<T, E>
@@ -67,7 +72,9 @@ where
 impl EndpointOutRegister for StatusError {
     #[inline]
     fn register(components: &mut Components, operation: &mut Operation) {
-        operation.responses.append(&mut Self::to_responses(components));
+        operation
+            .responses
+            .append(&mut Self::to_responses(components));
     }
 }
 impl EndpointOutRegister for StatusCode {
@@ -103,13 +110,17 @@ impl EndpointOutRegister for StatusCode {
                 ),
             )
         }
-        operation.responses.append(&mut StatusError::to_responses(components));
+        operation
+            .responses
+            .append(&mut StatusError::to_responses(components));
     }
 }
 impl EndpointOutRegister for salvo_core::Error {
     #[inline]
     fn register(components: &mut Components, operation: &mut Operation) {
-        operation.responses.append(&mut Self::to_responses(components));
+        operation
+            .responses
+            .append(&mut Self::to_responses(components));
     }
 }
 
diff --git a/crates/oapi/src/extract/parameter/cookie.rs b/crates/oapi/src/extract/parameter/cookie.rs
index a96ba0153..c399450b6 100644
--- a/crates/oapi/src/extract/parameter/cookie.rs
+++ b/crates/oapi/src/extract/parameter/cookie.rs
@@ -14,7 +14,8 @@ pub struct CookieParam<T, const REQUIRED: bool>(Option<T>);
 impl<T> CookieParam<T, true> {
     /// Consumes self and returns the value of the parameter.
     pub fn into_inner(self) -> T {
-        self.0.expect("`CookieParam<T, true>` into_inner get `None`")
+        self.0
+            .expect("`CookieParam<T, true>` into_inner get `None`")
     }
 }
 impl<T> CookieParam<T, false> {
@@ -28,7 +29,9 @@ impl<T> Deref for CookieParam<T, true> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        self.0.as_ref().expect("`CookieParam<T, true>` deref get `None`")
+        self.0
+            .as_ref()
+            .expect("`CookieParam<T, true>` deref get `None`")
     }
 }
 impl<T> Deref for CookieParam<T, false> {
@@ -41,7 +44,9 @@ impl<T> Deref for CookieParam<T, false> {
 
 impl<T> DerefMut for CookieParam<T, true> {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        self.0.as_mut().expect("`CookieParam<T, true>` deref_mut get `None`")
+        self.0
+            .as_mut()
+            .expect("`CookieParam<T, true>` deref_mut get `None`")
     }
 }
 impl<T> DerefMut for CookieParam<T, false> {
@@ -102,7 +107,10 @@ where
             .get(arg)
             .and_then(|v| from_str_val(v.value()).ok())
             .ok_or_else(|| {
-                ParseError::other(format!("cookie parameter {} not found or convert to type failed", arg))
+                ParseError::other(format!(
+                    "cookie parameter {} not found or convert to type failed",
+                    arg
+                ))
             })?;
         Ok(Self(value))
     }
@@ -122,7 +130,10 @@ where
     }
     #[allow(refining_impl_trait)]
     async fn extract_with_arg(req: &'ex mut Request, arg: &str) -> Result<Self, ParseError> {
-        let value = req.cookies().get(arg).and_then(|v| from_str_val(v.value()).ok());
+        let value = req
+            .cookies()
+            .get(arg)
+            .and_then(|v| from_str_val(v.value()).ok());
         Ok(Self(value))
     }
 }
diff --git a/crates/oapi/src/extract/parameter/header.rs b/crates/oapi/src/extract/parameter/header.rs
index b751e694e..771fd782a 100644
--- a/crates/oapi/src/extract/parameter/header.rs
+++ b/crates/oapi/src/extract/parameter/header.rs
@@ -13,7 +13,8 @@ pub struct HeaderParam<T, const REQUIRED: bool>(Option<T>);
 impl<T> HeaderParam<T, true> {
     /// Consumes self and returns the value of the parameter.
     pub fn into_inner(self) -> T {
-        self.0.expect("`HeaderParam<T, true>` into_inner get `None`")
+        self.0
+            .expect("`HeaderParam<T, true>` into_inner get `None`")
     }
 }
 impl<T> HeaderParam<T, false> {
@@ -27,7 +28,9 @@ impl<T> Deref for HeaderParam<T, true> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        self.0.as_ref().expect("`HeaderParam<T, true>` defref get `None`")
+        self.0
+            .as_ref()
+            .expect("`HeaderParam<T, true>` defref get `None`")
     }
 }
 impl<T> Deref for HeaderParam<T, false> {
@@ -40,7 +43,9 @@ impl<T> Deref for HeaderParam<T, false> {
 
 impl<T> DerefMut for HeaderParam<T, true> {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        self.0.as_mut().expect("`HeaderParam<T, true>` defref_mut get `None`")
+        self.0
+            .as_mut()
+            .expect("`HeaderParam<T, true>` defref_mut get `None`")
     }
 }
 impl<T> DerefMut for HeaderParam<T, false> {
@@ -85,7 +90,10 @@ where
     T: fmt::Display,
 {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        self.0.as_ref().expect("HeaderParam value should not None.").fmt(f)
+        self.0
+            .as_ref()
+            .expect("HeaderParam value should not None.")
+            .fmt(f)
     }
 }
 
@@ -104,7 +112,10 @@ where
     #[allow(refining_impl_trait)]
     async fn extract_with_arg(req: &'ex mut Request, arg: &str) -> Result<Self, ParseError> {
         let value = req.header(arg).ok_or_else(|| {
-            ParseError::other(format!("header parameter {} not found or convert to type failed", arg))
+            ParseError::other(format!(
+                "header parameter {} not found or convert to type failed",
+                arg
+            ))
         })?;
         Ok(Self(value))
     }
@@ -221,7 +232,8 @@ mod tests {
     #[tokio::test]
     async fn test_required_header_prarm_extract_with_value() {
         let mut req = TestClient::get("http://127.0.0.1:5801").build_hyper();
-        req.headers_mut().append("param", HeaderValue::from_static("param"));
+        req.headers_mut()
+            .append("param", HeaderValue::from_static("param"));
         let schema = req.uri().scheme().cloned().unwrap();
         let mut req = Request::from_hyper(req, schema);
         let result = HeaderParam::<String, true>::extract_with_arg(&mut req, "param").await;
@@ -254,7 +266,8 @@ mod tests {
     #[tokio::test]
     async fn test_header_prarm_extract_with_value() {
         let mut req = TestClient::get("http://127.0.0.1:5801").build_hyper();
-        req.headers_mut().append("param", HeaderValue::from_static("param"));
+        req.headers_mut()
+            .append("param", HeaderValue::from_static("param"));
         let schema = req.uri().scheme().cloned().unwrap();
         let mut req = Request::from_hyper(req, schema);
         let result = HeaderParam::<String, false>::extract_with_arg(&mut req, "param").await;
diff --git a/crates/oapi/src/extract/parameter/path.rs b/crates/oapi/src/extract/parameter/path.rs
index 399f5984c..dba2ab2f1 100644
--- a/crates/oapi/src/extract/parameter/path.rs
+++ b/crates/oapi/src/extract/parameter/path.rs
@@ -75,9 +75,12 @@ where
     }
     #[allow(refining_impl_trait)]
     async fn extract_with_arg(req: &'ex mut Request, arg: &str) -> Result<Self, ParseError> {
-        let value = req
-            .param(arg)
-            .ok_or_else(|| ParseError::other(format!("path parameter {} not found or convert to type failed", arg)))?;
+        let value = req.param(arg).ok_or_else(|| {
+            ParseError::other(format!(
+                "path parameter {} not found or convert to type failed",
+                arg
+            ))
+        })?;
         Ok(Self(value))
     }
 }
diff --git a/crates/oapi/src/extract/parameter/query.rs b/crates/oapi/src/extract/parameter/query.rs
index 62e3dfc2c..c0274be29 100644
--- a/crates/oapi/src/extract/parameter/query.rs
+++ b/crates/oapi/src/extract/parameter/query.rs
@@ -28,7 +28,9 @@ impl<T> Deref for QueryParam<T, true> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        self.0.as_ref().expect("`QueryParam<T, true>` defref get `None`")
+        self.0
+            .as_ref()
+            .expect("`QueryParam<T, true>` defref get `None`")
     }
 }
 impl<T> Deref for QueryParam<T, false> {
@@ -41,7 +43,9 @@ impl<T> Deref for QueryParam<T, false> {
 
 impl<T> DerefMut for QueryParam<T, true> {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        self.0.as_mut().expect("`QueryParam<T, true>` defref_mut get `None`")
+        self.0
+            .as_mut()
+            .expect("`QueryParam<T, true>` defref_mut get `None`")
     }
 }
 impl<T> DerefMut for QueryParam<T, false> {
@@ -76,7 +80,10 @@ where
     T: fmt::Display,
 {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        self.0.as_ref().expect("`QueryParam<T, true>` as_ref get `None`").fmt(f)
+        self.0
+            .as_ref()
+            .expect("`QueryParam<T, true>` as_ref get `None`")
+            .fmt(f)
     }
 }
 
@@ -94,9 +101,12 @@ where
     }
     #[allow(refining_impl_trait)]
     async fn extract_with_arg(req: &'ex mut Request, arg: &str) -> Result<Self, ParseError> {
-        let value = req
-            .query(arg)
-            .ok_or_else(|| ParseError::other(format!("query parameter {} not found or convert to type failed", arg)))?;
+        let value = req.query(arg).ok_or_else(|| {
+            ParseError::other(format!(
+                "query parameter {} not found or convert to type failed",
+                arg
+            ))
+        })?;
         Ok(Self(value))
     }
 }
@@ -212,7 +222,8 @@ mod tests {
         let req = TestClient::get("http://127.0.0.1:5801").build_hyper();
         let schema = req.uri().scheme().cloned().unwrap();
         let mut req = Request::from_hyper(req, schema);
-        req.queries_mut().insert("param".to_string(), "param".to_string());
+        req.queries_mut()
+            .insert("param".to_string(), "param".to_string());
         let result = QueryParam::<String, true>::extract_with_arg(&mut req, "param").await;
         assert_eq!(result.unwrap().0.unwrap(), "param");
     }
@@ -245,7 +256,8 @@ mod tests {
         let req = TestClient::get("http://127.0.0.1:5801").build_hyper();
         let schema = req.uri().scheme().cloned().unwrap();
         let mut req = Request::from_hyper(req, schema);
-        req.queries_mut().insert("param".to_string(), "param".to_string());
+        req.queries_mut()
+            .insert("param".to_string(), "param".to_string());
         let result = QueryParam::<String, false>::extract_with_arg(&mut req, "param").await;
         assert_eq!(result.unwrap().0.unwrap(), "param");
     }
diff --git a/crates/oapi/src/extract/payload/file.rs b/crates/oapi/src/extract/payload/file.rs
index 20790cf6a..9605b6da9 100644
--- a/crates/oapi/src/extract/payload/file.rs
+++ b/crates/oapi/src/extract/payload/file.rs
@@ -8,7 +8,10 @@ use salvo_core::http::{HeaderMap, Mime, ParseError};
 use salvo_core::{async_trait, Request};
 
 use crate::endpoint::EndpointArgRegister;
-use crate::{Array, BasicType, Components, Content, KnownFormat, Object, Operation, RequestBody, Schema, SchemaFormat};
+use crate::{
+    Array, BasicType, Components, Content, KnownFormat, Object, Operation, RequestBody, Schema,
+    SchemaFormat,
+};
 
 /// Represents the upload file.
 #[derive(Clone, Debug)]
@@ -93,10 +96,13 @@ impl<'ex> Extractible<'ex> for FormFile {
 #[async_trait]
 impl EndpointArgRegister for FormFile {
     fn register(_components: &mut Components, operation: &mut Operation, arg: &str) {
-        let schema = Schema::from(Object::new().property(
-            arg,
-            Object::with_type(BasicType::String).format(SchemaFormat::KnownFormat(KnownFormat::Binary)),
-        ));
+        let schema = Schema::from(
+            Object::new().property(
+                arg,
+                Object::with_type(BasicType::String)
+                    .format(SchemaFormat::KnownFormat(KnownFormat::Binary)),
+            ),
+        );
 
         if let Some(request_body) = &mut operation.request_body {
             request_body
@@ -164,12 +170,15 @@ impl<'ex> Extractible<'ex> for FormFiles {
 #[async_trait]
 impl EndpointArgRegister for FormFiles {
     fn register(_components: &mut Components, operation: &mut Operation, arg: &str) {
-        let schema = Schema::from(Object::new().property(
-            arg,
-            Array::new().items(Schema::from(
-                Object::with_type(BasicType::String).format(SchemaFormat::KnownFormat(KnownFormat::Binary)),
-            )),
-        ));
+        let schema = Schema::from(
+            Object::new().property(
+                arg,
+                Array::new().items(Schema::from(
+                    Object::with_type(BasicType::String)
+                        .format(SchemaFormat::KnownFormat(KnownFormat::Binary)),
+                )),
+            ),
+        );
         if let Some(request_body) = &mut operation.request_body {
             request_body
                 .contents
diff --git a/crates/oapi/src/extract/payload/form.rs b/crates/oapi/src/extract/payload/form.rs
index 0dd7cbab4..6286f6715 100644
--- a/crates/oapi/src/extract/payload/form.rs
+++ b/crates/oapi/src/extract/payload/form.rs
@@ -72,7 +72,9 @@ where
         static METADATA: Metadata = Metadata::new("");
         &METADATA
     }
-    async fn extract(req: &'ex mut Request) -> Result<Self, impl Writer + Send + fmt::Debug + 'static> {
+    async fn extract(
+        req: &'ex mut Request,
+    ) -> Result<Self, impl Writer + Send + fmt::Debug + 'static> {
         req.parse_form().await
     }
     async fn extract_with_arg(
@@ -180,7 +182,9 @@ mod tests {
     #[tokio::test]
     async fn test_form_body_extract_with_arg() {
         let map = BTreeMap::from_iter([("key", "value")]);
-        let mut req = TestClient::post("http://127.0.0.1:5800/").form(&map).build();
+        let mut req = TestClient::post("http://127.0.0.1:5800/")
+            .form(&map)
+            .build();
         let result = FormBody::<BTreeMap<&str, &str>>::extract_with_arg(&mut req, "key").await;
         assert_eq!("value", result.unwrap().0["key"]);
     }
diff --git a/crates/oapi/src/extract/payload/json.rs b/crates/oapi/src/extract/payload/json.rs
index c39a5d9b7..fb39903c1 100644
--- a/crates/oapi/src/extract/payload/json.rs
+++ b/crates/oapi/src/extract/payload/json.rs
@@ -68,7 +68,9 @@ where
         static METADATA: Metadata = Metadata::new("");
         &METADATA
     }
-    async fn extract(req: &'ex mut Request) -> Result<Self, impl Writer + Send + fmt::Debug + 'static> {
+    async fn extract(
+        req: &'ex mut Request,
+    ) -> Result<Self, impl Writer + Send + fmt::Debug + 'static> {
         req.parse_json().await
     }
     async fn extract_with_arg(
@@ -170,7 +172,9 @@ mod tests {
     #[tokio::test]
     async fn test_json_body_extract_with_arg() {
         let map = BTreeMap::from_iter([("key", "value")]);
-        let mut req = TestClient::post("http://127.0.0.1:5800/").json(&map).build();
+        let mut req = TestClient::post("http://127.0.0.1:5800/")
+            .json(&map)
+            .build();
         let result = JsonBody::<BTreeMap<&str, &str>>::extract_with_arg(&mut req, "key").await;
         assert_eq!("value", result.unwrap().0["key"]);
     }
diff --git a/crates/oapi/src/lib.rs b/crates/oapi/src/lib.rs
index 6dbfdd611..f1cf8734e 100644
--- a/crates/oapi/src/lib.rs
+++ b/crates/oapi/src/lib.rs
@@ -564,7 +564,10 @@ impl ToResponses for StatusError {
         for StatusError { code, brief, .. } in errors {
             responses.insert(
                 code.as_str(),
-                Response::new(brief).add_content("application/json", Content::new(StatusError::to_schema(components))),
+                Response::new(brief).add_content(
+                    "application/json",
+                    Content::new(StatusError::to_schema(components)),
+                ),
             )
         }
         responses
@@ -643,8 +646,16 @@ mod tests {
                 i64::to_schema(&mut components),
                 json!({"type": "integer", "format": "int64"}),
             ),
-            ("i128", i128::to_schema(&mut components), json!({"type": "integer"})),
-            ("isize", isize::to_schema(&mut components), json!({"type": "integer"})),
+            (
+                "i128",
+                i128::to_schema(&mut components),
+                json!({"type": "integer"}),
+            ),
+            (
+                "isize",
+                isize::to_schema(&mut components),
+                json!({"type": "integer"}),
+            ),
             (
                 "u8",
                 u8::to_schema(&mut components),
@@ -675,10 +686,26 @@ mod tests {
                 usize::to_schema(&mut components),
                 json!({"type": "integer", "minimum": 0.0 }),
             ),
-            ("bool", bool::to_schema(&mut components), json!({"type": "boolean"})),
-            ("str", str::to_schema(&mut components), json!({"type": "string"})),
-            ("String", String::to_schema(&mut components), json!({"type": "string"})),
-            ("char", char::to_schema(&mut components), json!({"type": "string"})),
+            (
+                "bool",
+                bool::to_schema(&mut components),
+                json!({"type": "boolean"}),
+            ),
+            (
+                "str",
+                str::to_schema(&mut components),
+                json!({"type": "string"}),
+            ),
+            (
+                "String",
+                String::to_schema(&mut components),
+                json!({"type": "string"}),
+            ),
+            (
+                "char",
+                char::to_schema(&mut components),
+                json!({"type": "string"}),
+            ),
             (
                 "f32",
                 f32::to_schema(&mut components),
@@ -690,7 +717,10 @@ mod tests {
                 json!({"type": "number", "format": "double"}),
             ),
         ] {
-            println!("{name}: {json}", json = serde_json::to_string(&schema).unwrap());
+            println!(
+                "{name}: {json}",
+                json = serde_json::to_string(&schema).unwrap()
+            );
             let schema = serde_json::to_value(schema).unwrap();
             assert_json_eq!(schema, value);
         }
diff --git a/crates/oapi/src/naming.rs b/crates/oapi/src/naming.rs
index 6f1d48d47..714a65763 100644
--- a/crates/oapi/src/naming.rs
+++ b/crates/oapi/src/naming.rs
@@ -15,8 +15,10 @@ pub enum NameRule {
     Force(&'static str),
 }
 
-static GLOBAL_NAMER: LazyLock<RwLock<Box<dyn Namer>>> = LazyLock::new(|| RwLock::new(Box::new(FlexNamer::new())));
-static NAME_TYPES: LazyLock<RwLock<BTreeMap<String, (TypeId, &'static str)>>> = LazyLock::new(Default::default);
+static GLOBAL_NAMER: LazyLock<RwLock<Box<dyn Namer>>> =
+    LazyLock::new(|| RwLock::new(Box::new(FlexNamer::new())));
+static NAME_TYPES: LazyLock<RwLock<BTreeMap<String, (TypeId, &'static str)>>> =
+    LazyLock::new(Default::default);
 
 /// Set global namer.
 ///
@@ -49,8 +51,14 @@ pub fn type_info_by_name(name: &str) -> Option<(TypeId, &'static str)> {
 }
 
 /// Set type info by name.
-pub fn set_name_type_info(name: String, type_id: TypeId, type_name: &'static str) -> Option<(TypeId, &'static str)> {
-    NAME_TYPES.write().insert(name.clone(), (type_id, type_name))
+pub fn set_name_type_info(
+    name: String,
+    type_id: TypeId,
+    type_name: &'static str,
+) -> Option<(TypeId, &'static str)> {
+    NAME_TYPES
+        .write()
+        .insert(name.clone(), (type_id, type_name))
 }
 
 /// Assign name to type and returns the name.
@@ -75,7 +83,10 @@ pub fn get_name<T: 'static>() -> String {
             return name.clone();
         }
     }
-    panic!("Type not found in the name registry: {:?}", std::any::type_name::<T>());
+    panic!(
+        "Type not found in the name registry: {:?}",
+        std::any::type_name::<T>()
+    );
 }
 
 fn type_generic_part(type_name: &str) -> String {
diff --git a/crates/oapi/src/openapi/components.rs b/crates/oapi/src/openapi/components.rs
index 80eaff546..e0d43d8e2 100644
--- a/crates/oapi/src/openapi/components.rs
+++ b/crates/oapi/src/openapi/components.rs
@@ -57,7 +57,8 @@ impl Components {
         name: N,
         security_scheme: S,
     ) -> Self {
-        self.security_schemes.insert(name.into(), security_scheme.into());
+        self.security_schemes
+            .insert(name.into(), security_scheme.into());
 
         self
     }
@@ -68,19 +69,30 @@ impl Components {
     /// referenced by [`SecurityRequirement`][requirement]s. Second parameter is the [`SecurityScheme`].
     ///
     /// [requirement]: crate::SecurityRequirement
-    pub fn extend_security_schemes<I: IntoIterator<Item = (N, S)>, N: Into<String>, S: Into<SecurityScheme>>(
+    pub fn extend_security_schemes<
+        I: IntoIterator<Item = (N, S)>,
+        N: Into<String>,
+        S: Into<SecurityScheme>,
+    >(
         mut self,
         schemas: I,
     ) -> Self {
-        self.security_schemes
-            .extend(schemas.into_iter().map(|(name, item)| (name.into(), item.into())));
+        self.security_schemes.extend(
+            schemas
+                .into_iter()
+                .map(|(name, item)| (name.into(), item.into())),
+        );
         self
     }
 
     /// Add [`Schema`] to [`Components`] and returns `Self`.
     ///
     /// Accepts two arguments where first is name of the schema and second is the schema itself.
-    pub fn add_schema<S: Into<String>, I: Into<RefOr<Schema>>>(mut self, name: S, schema: I) -> Self {
+    pub fn add_schema<S: Into<String>, I: Into<RefOr<Schema>>>(
+        mut self,
+        name: S,
+        schema: I,
+    ) -> Self {
         self.schemas.insert(name, schema);
         self
     }
@@ -108,19 +120,30 @@ impl Components {
         C: Into<RefOr<Schema>>,
         S: Into<String>,
     {
-        self.schemas
-            .extend(schemas.into_iter().map(|(name, schema)| (name.into(), schema.into())));
+        self.schemas.extend(
+            schemas
+                .into_iter()
+                .map(|(name, schema)| (name.into(), schema.into())),
+        );
         self
     }
 
     /// Add a new response and returns `self`.
-    pub fn response<S: Into<String>, R: Into<RefOr<Response>>>(mut self, name: S, response: R) -> Self {
+    pub fn response<S: Into<String>, R: Into<RefOr<Response>>>(
+        mut self,
+        name: S,
+        response: R,
+    ) -> Self {
         self.responses.insert(name.into(), response.into());
         self
     }
 
     /// Extends responses with the contents of an iterator.
-    pub fn extend_responses<I: IntoIterator<Item = (S, R)>, S: Into<String>, R: Into<RefOr<Response>>>(
+    pub fn extend_responses<
+        I: IntoIterator<Item = (S, R)>,
+        S: Into<String>,
+        R: Into<RefOr<Response>>,
+    >(
         mut self,
         responses: I,
     ) -> Self {
@@ -137,10 +160,14 @@ impl Components {
     /// If a key from `other` is already present in `self`, the respective
     /// value from `self` will be overwritten with the respective value from `other`.
     pub fn append(&mut self, other: &mut Components) {
-        other.schemas.retain(|name, _| !self.schemas.contains_key(name));
+        other
+            .schemas
+            .retain(|name, _| !self.schemas.contains_key(name));
         self.schemas.append(&mut other.schemas);
 
-        other.responses.retain(|name, _| !self.responses.contains_key(name));
+        other
+            .responses
+            .retain(|name, _| !self.responses.contains_key(name));
         self.responses.append(&mut other.responses);
 
         other
diff --git a/crates/oapi/src/openapi/content.rs b/crates/oapi/src/openapi/content.rs
index 2d4e12394..8617b4d0b 100644
--- a/crates/oapi/src/openapi/content.rs
+++ b/crates/oapi/src/openapi/content.rs
@@ -66,7 +66,11 @@ impl Content {
     /// `examples` will override value in `example`.
     ///
     /// [example]: ../example/Example.html
-    pub fn extend_examples<E: IntoIterator<Item = (N, V)>, N: Into<String>, V: Into<RefOr<Example>>>(
+    pub fn extend_examples<
+        E: IntoIterator<Item = (N, V)>,
+        N: Into<String>,
+        V: Into<RefOr<Example>>,
+    >(
         mut self,
         examples: E,
     ) -> Self {
@@ -87,7 +91,11 @@ impl Content {
     ///
     /// The encoding object SHALL only apply to `request_body` objects when the media type is
     /// multipart or `application/x-www-form-urlencoded`.
-    pub fn encoding<S: Into<String>, E: Into<Encoding>>(mut self, property_name: S, encoding: E) -> Self {
+    pub fn encoding<S: Into<String>, E: Into<Encoding>>(
+        mut self,
+        property_name: S,
+        encoding: E,
+    ) -> Self {
         self.encoding.insert(property_name.into(), encoding.into());
         self
     }
@@ -116,7 +124,10 @@ mod tests {
                 "schema".into(),
                 Value::String("MySchema".to_string()),
             )])))
-            .encoding("schema".to_string(), Encoding::default().content_type("text/plain"));
+            .encoding(
+                "schema".to_string(),
+                Encoding::default().content_type("text/plain"),
+            );
         assert_json_eq!(
             content,
             json!({
diff --git a/crates/oapi/src/openapi/external_docs.rs b/crates/oapi/src/openapi/external_docs.rs
index 40465240b..0286d56f2 100644
--- a/crates/oapi/src/openapi/external_docs.rs
+++ b/crates/oapi/src/openapi/external_docs.rs
@@ -64,6 +64,9 @@ mod tests {
             .description("description");
 
         assert_eq!(external_docs_with_url.url, "https://pet-api.external.docs");
-        assert_eq!(external_docs_with_url.description, Some("description".to_string()));
+        assert_eq!(
+            external_docs_with_url.description,
+            Some("description".to_string())
+        );
     }
 }
diff --git a/crates/oapi/src/openapi/mod.rs b/crates/oapi/src/openapi/mod.rs
index 0fc0030d2..fa72cdd79 100644
--- a/crates/oapi/src/openapi/mod.rs
+++ b/crates/oapi/src/openapi/mod.rs
@@ -40,7 +40,8 @@ pub use self::{
     request_body::RequestBody,
     response::{Response, Responses},
     schema::{
-        Array, BasicType, Discriminator, KnownFormat, Object, Ref, Schema, SchemaFormat, SchemaType, Schemas, ToArray,
+        Array, BasicType, Discriminator, KnownFormat, Object, Ref, Schema, SchemaFormat,
+        SchemaType, Schemas, ToArray,
     },
     security::{SecurityRequirement, SecurityScheme},
     server::{Server, ServerVariable, ServerVariables, Servers},
@@ -49,7 +50,8 @@ pub use self::{
 };
 use crate::{routing::NormNode, Endpoint};
 
-static PATH_PARAMETER_NAME_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\{([^}:]+)").expect("invalid regex"));
+static PATH_PARAMETER_NAME_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"\{([^}:]+)").expect("invalid regex"));
 
 /// The structure of the internal storage object paths.
 #[cfg(not(feature = "preserve-path-order"))]
@@ -279,20 +281,30 @@ impl OpenApi {
     /// referenced by [`SecurityRequirement`][requirement]s. Second parameter is the [`SecurityScheme`].
     ///
     /// [requirement]: crate::SecurityRequirement
-    pub fn extend_security_schemes<I: IntoIterator<Item = (N, S)>, N: Into<String>, S: Into<SecurityScheme>>(
+    pub fn extend_security_schemes<
+        I: IntoIterator<Item = (N, S)>,
+        N: Into<String>,
+        S: Into<SecurityScheme>,
+    >(
         mut self,
         schemas: I,
     ) -> Self {
-        self.components
-            .security_schemes
-            .extend(schemas.into_iter().map(|(name, item)| (name.into(), item.into())));
+        self.components.security_schemes.extend(
+            schemas
+                .into_iter()
+                .map(|(name, item)| (name.into(), item.into())),
+        );
         self
     }
 
     /// Add [`Schema`] to [`Components`] and returns `Self`.
     ///
     /// Accepts two arguments where first is name of the schema and second is the schema itself.
-    pub fn add_schema<S: Into<String>, I: Into<RefOr<Schema>>>(mut self, name: S, schema: I) -> Self {
+    pub fn add_schema<S: Into<String>, I: Into<RefOr<Schema>>>(
+        mut self,
+        name: S,
+        schema: I,
+    ) -> Self {
         self.components.schemas.insert(name, schema);
         self
     }
@@ -320,20 +332,32 @@ impl OpenApi {
         C: Into<RefOr<Schema>>,
         S: Into<String>,
     {
-        self.components
-            .schemas
-            .extend(schemas.into_iter().map(|(name, schema)| (name.into(), schema.into())));
+        self.components.schemas.extend(
+            schemas
+                .into_iter()
+                .map(|(name, schema)| (name.into(), schema.into())),
+        );
         self
     }
 
     /// Add a new response and returns `self`.
-    pub fn response<S: Into<String>, R: Into<RefOr<Response>>>(mut self, name: S, response: R) -> Self {
-        self.components.responses.insert(name.into(), response.into());
+    pub fn response<S: Into<String>, R: Into<RefOr<Response>>>(
+        mut self,
+        name: S,
+        response: R,
+    ) -> Self {
+        self.components
+            .responses
+            .insert(name.into(), response.into());
         self
     }
 
     /// Extends responses with the contents of an iterator.
-    pub fn extend_responses<I: IntoIterator<Item = (S, R)>, S: Into<String>, R: Into<RefOr<Response>>>(
+    pub fn extend_responses<
+        I: IntoIterator<Item = (S, R)>,
+        S: Into<String>,
+        R: Into<RefOr<Response>>,
+    >(
         mut self,
         responses: I,
     ) -> Self {
@@ -410,7 +434,12 @@ impl OpenApi {
                 captures
                     .iter()
                     .skip(1)
-                    .map(|capture| capture.expect("Regex captures should not be None.").as_str().to_owned())
+                    .map(|capture| {
+                        capture
+                            .expect("Regex captures should not be None.")
+                            .as_str()
+                            .to_owned()
+                    })
                     .next()
             })
             .collect::<Vec<_>>();
@@ -422,7 +451,9 @@ impl OpenApi {
                     ..
                 } = (creator)();
                 operation.tags.extend(node.metadata.tags.iter().cloned());
-                operation.securities.extend(node.metadata.securities.iter().cloned());
+                operation
+                    .securities
+                    .extend(node.metadata.securities.iter().cloned());
                 let methods = if let Some(method) = &node.method {
                     vec![*method]
                 } else {
@@ -437,7 +468,10 @@ impl OpenApi {
                     .parameters
                     .0
                     .iter()
-                    .filter(|p| p.parameter_in == ParameterIn::Path && !path_parameter_names.contains(&p.name))
+                    .filter(|p| {
+                        p.parameter_in == ParameterIn::Path
+                            && !path_parameter_names.contains(&p.name)
+                    })
                     .map(|p| &p.name)
                     .collect::<Vec<_>>();
                 if !not_exist_parameters.is_empty() {
@@ -448,7 +482,8 @@ impl OpenApi {
                     .filter(|name| {
                         !name.starts_with('*')
                             && !operation.parameters.0.iter().any(|parameter| {
-                                parameter.name == **name && parameter.parameter_in == ParameterIn::Path
+                                parameter.name == **name
+                                    && parameter.parameter_in == ParameterIn::Path
                             })
                     })
                     .collect::<Vec<_>>();
@@ -460,7 +495,11 @@ impl OpenApi {
                     if let btree_map::Entry::Vacant(e) = path_item.operations.entry(method) {
                         e.insert(operation.clone());
                     } else {
-                        tracing::warn!("path `{}` already contains operation for method `{:?}`", path, method);
+                        tracing::warn!(
+                            "path `{}` already contains operation for method `{:?}`",
+                            path,
+                            method
+                        );
                     }
                 }
                 self.components.append(&mut components);
@@ -481,7 +520,11 @@ impl Handler for OpenApi {
         res: &mut salvo_core::Response,
         _ctrl: &mut FlowCtrl,
     ) {
-        let pretty = req.queries().get("pretty").map(|v| &**v != "false").unwrap_or(false);
+        let pretty = req
+            .queries()
+            .get("pretty")
+            .map(|v| &**v != "false")
+            .unwrap_or(false);
         let content = if pretty {
             self.to_pretty_json().unwrap_or_default()
         } else {
@@ -526,13 +569,19 @@ impl<'de> Deserialize<'de> for OpenApiVersion {
             where
                 E: Error,
             {
-                let version = v.split('.').flat_map(|digit| digit.parse::<i8>()).collect::<Vec<_>>();
+                let version = v
+                    .split('.')
+                    .flat_map(|digit| digit.parse::<i8>())
+                    .collect::<Vec<_>>();
 
                 if version.len() == 3 && version.first() == Some(&3) && version.get(1) == Some(&1) {
                     Ok(OpenApiVersion::Version3_1)
                 } else {
                     let expected: &dyn Expected = &"3.1.0";
-                    Err(Error::invalid_value(serde::de::Unexpected::Str(&v), expected))
+                    Err(Error::invalid_value(
+                        serde::de::Unexpected::Str(&v),
+                        expected,
+                    ))
                 }
             }
         }
@@ -828,7 +877,8 @@ mod tests {
                         "/ap/v2/user",
                         PathItem::new(
                             PathItemType::Get,
-                            Operation::new().add_response("200", Response::new("Get user success 2")),
+                            Operation::new()
+                                .add_response("200", Response::new("Get user success 2")),
                         ),
                     )
                     .path(
@@ -1081,7 +1131,10 @@ mod tests {
         let _doc = OpenApi::new("pet api", "0.1.0")
             .info(Info::new("my pet api", "0.2.0"))
             .servers(Servers::new())
-            .add_path("/api/v1", PathItem::new(PathItemType::Get, Operation::new()))
+            .add_path(
+                "/api/v1",
+                PathItem::new(PathItemType::Get, Operation::new()),
+            )
             .security([SecurityRequirement::default()])
             .add_security_scheme(
                 "api_key",
@@ -1192,7 +1245,8 @@ mod tests {
         let doc = OpenApi::new("pet api", "0.1.0");
 
         let mut req = Request::new();
-        req.queries_mut().insert("pretty".to_string(), "true".to_string());
+        req.queries_mut()
+            .insert("pretty".to_string(), "true".to_string());
 
         let mut depot = Depot::new();
         let mut res = salvo_core::Response::new();
@@ -1239,7 +1293,11 @@ mod tests {
             pub(crate) data: T,
         }
 
-        #[salvo_oapi::endpoint(operation_id = "get_all_cities", tags("city"), status_codes(200, 400, 401, 403, 500))]
+        #[salvo_oapi::endpoint(
+            operation_id = "get_all_cities",
+            tags("city"),
+            status_codes(200, 400, 401, 403, 500)
+        )]
         pub async fn get_all_cities() -> Result<Json<ApiResponse<Vec<CityDTO>>>, StatusError> {
             Ok(Json(ApiResponse {
                 status: "200".to_string(),
diff --git a/crates/oapi/src/openapi/operation.rs b/crates/oapi/src/openapi/operation.rs
index 98e8b2e12..25d719688 100644
--- a/crates/oapi/src/openapi/operation.rs
+++ b/crates/oapi/src/openapi/operation.rs
@@ -47,13 +47,21 @@ impl Operations {
         self.0.is_empty()
     }
     /// Add a new operation and returns `self`.
-    pub fn operation<K: Into<PathItemType>, O: Into<Operation>>(mut self, item_type: K, operation: O) -> Self {
+    pub fn operation<K: Into<PathItemType>, O: Into<Operation>>(
+        mut self,
+        item_type: K,
+        operation: O,
+    ) -> Self {
         self.insert(item_type, operation);
         self
     }
 
     /// Inserts a key-value pair into the instance.
-    pub fn insert<K: Into<PathItemType>, O: Into<Operation>>(&mut self, item_type: K, operation: O) {
+    pub fn insert<K: Into<PathItemType>, O: Into<Operation>>(
+        &mut self,
+        item_type: K,
+        operation: O,
+    ) {
         self.0.insert(item_type.into(), operation.into());
     }
 
@@ -202,7 +210,10 @@ impl Operation {
     }
 
     /// Add or change parameters of the [`Operation`].
-    pub fn parameters<I: IntoIterator<Item = P>, P: Into<Parameter>>(mut self, parameters: I) -> Self {
+    pub fn parameters<I: IntoIterator<Item = P>, P: Into<Parameter>>(
+        mut self,
+        parameters: I,
+    ) -> Self {
         self.parameters
             .extend(parameters.into_iter().map(|parameter| parameter.into()));
         self
@@ -228,7 +239,11 @@ impl Operation {
     ///
     /// * `code` must be valid HTTP status code.
     /// * `response` is instances of [`Response`].
-    pub fn add_response<S: Into<String>, R: Into<RefOr<Response>>>(mut self, code: S, response: R) -> Self {
+    pub fn add_response<S: Into<String>, R: Into<RefOr<Response>>>(
+        mut self,
+        code: S,
+        response: R,
+    ) -> Self {
         self.responses.insert(code, response);
         self
     }
@@ -240,7 +255,10 @@ impl Operation {
     }
 
     /// Add or change list of [`SecurityRequirement`]s that are available for [`Operation`].
-    pub fn securities<I: IntoIterator<Item = SecurityRequirement>>(mut self, securities: I) -> Self {
+    pub fn securities<I: IntoIterator<Item = SecurityRequirement>>(
+        mut self,
+        securities: I,
+    ) -> Self {
         self.securities = securities.into_iter().collect();
         self
     }
@@ -277,7 +295,8 @@ mod tests {
 
     use super::{Operation, Operations};
     use crate::{
-        security::SecurityRequirement, server::Server, Deprecated, Parameter, PathItemType, RequestBody, Responses,
+        security::SecurityRequirement, server::Server, Deprecated, Parameter, PathItemType,
+        RequestBody, Responses,
     };
 
     #[test]
@@ -350,7 +369,8 @@ mod tests {
 
     #[test]
     fn operation_security() {
-        let security_requirement1 = SecurityRequirement::new("api_oauth2_flow", ["edit:items", "read:items"]);
+        let security_requirement1 =
+            SecurityRequirement::new("api_oauth2_flow", ["edit:items", "read:items"]);
         let security_requirement2 = SecurityRequirement::new("api_oauth2_flow", ["remove:items"]);
         let operation = Operation::new()
             .add_security(security_requirement1)
diff --git a/crates/oapi/src/openapi/parameter.rs b/crates/oapi/src/openapi/parameter.rs
index 454a8735b..734b2b936 100644
--- a/crates/oapi/src/openapi/parameter.rs
+++ b/crates/oapi/src/openapi/parameter.rs
@@ -44,10 +44,9 @@ impl Parameters {
     /// Inserts a parameter into the instance.
     pub fn insert<P: Into<Parameter>>(&mut self, parameter: P) {
         let parameter = parameter.into();
-        let exist_item = self
-            .0
-            .iter_mut()
-            .find(|item| item.name == parameter.name && item.parameter_in == parameter.parameter_in);
+        let exist_item = self.0.iter_mut().find(|item| {
+            item.name == parameter.name && item.parameter_in == parameter.parameter_in
+        });
 
         if let Some(exist_item) = exist_item {
             exist_item.merge(parameter);
diff --git a/crates/oapi/src/openapi/path.rs b/crates/oapi/src/openapi/path.rs
index 72c7b5419..39456e6bc 100644
--- a/crates/oapi/src/openapi/path.rs
+++ b/crates/oapi/src/openapi/path.rs
@@ -141,7 +141,11 @@ impl PathItem {
 
     /// Append a new [`Operation`] by [`PathItemType`] to this [`PathItem`]. Operations can
     /// hold only one operation per [`PathItemType`].
-    pub fn add_operation<O: Into<Operation>>(mut self, path_item_type: PathItemType, operation: O) -> Self {
+    pub fn add_operation<O: Into<Operation>>(
+        mut self,
+        path_item_type: PathItemType,
+        operation: O,
+    ) -> Self {
         self.operations.insert(path_item_type, operation.into());
         self
     }
diff --git a/crates/oapi/src/openapi/response.rs b/crates/oapi/src/openapi/response.rs
index 617df4e1a..d696ed713 100644
--- a/crates/oapi/src/openapi/response.rs
+++ b/crates/oapi/src/openapi/response.rs
@@ -26,7 +26,12 @@ where
     R: Into<RefOr<Response>>,
 {
     fn from(inner: BTreeMap<K, R>) -> Self {
-        Self(inner.into_iter().map(|(k, v)| (k.into(), v.into())).collect())
+        Self(
+            inner
+                .into_iter()
+                .map(|(k, v)| (k.into(), v.into()))
+                .collect(),
+        )
     }
 }
 impl<K, R, const N: usize> From<[(K, R); N]> for Responses
@@ -73,7 +78,11 @@ impl Responses {
         Default::default()
     }
     /// Inserts a key-value pair into the instance and retuns `self`.
-    pub fn response<S: Into<String>, R: Into<RefOr<Response>>>(mut self, key: S, response: R) -> Self {
+    pub fn response<S: Into<String>, R: Into<RefOr<Response>>>(
+        mut self,
+        key: S,
+        response: R,
+    ) -> Self {
         self.insert(key, response);
         self
     }
@@ -98,8 +107,10 @@ impl Responses {
         C: Into<String>,
         R: Into<RefOr<Response>>,
     {
-        self.0
-            .extend(iter.into_iter().map(|(key, response)| (key.into(), response.into())));
+        self.0.extend(
+            iter.into_iter()
+                .map(|(key, response)| (key.into(), response.into())),
+        );
     }
 }
 
@@ -116,7 +127,8 @@ where
 {
     fn from_iter<T: IntoIterator<Item = (C, R)>>(iter: T) -> Self {
         Self(BTreeMap::from_iter(
-            iter.into_iter().map(|(key, response)| (key.into(), response.into())),
+            iter.into_iter()
+                .map(|(key, response)| (key.into(), response.into())),
         ))
     }
 }
@@ -205,7 +217,10 @@ mod tests {
                 "application/json",
                 Content::new(Ref::from_schema_name("MySchemaPayload")),
             )
-            .add_header("content-type", Header::default().description("application/json"));
+            .add_header(
+                "content-type",
+                Header::default().description("application/json"),
+            );
 
         assert_json_eq!(
             request_body,
@@ -239,8 +254,14 @@ mod tests {
         ]);
 
         let expected = Responses(BTreeMap::from([
-            ("response1".to_string(), RefOr::T(Response::new("response1"))),
-            ("response2".to_string(), RefOr::T(Response::new("response2"))),
+            (
+                "response1".to_string(),
+                RefOr::T(Response::new("response1")),
+            ),
+            (
+                "response2".to_string(),
+                RefOr::T(Response::new("response2")),
+            ),
         ]));
 
         let actual = Responses::from(input);
@@ -256,8 +277,14 @@ mod tests {
         ];
 
         let expected = Responses(BTreeMap::from([
-            ("response1".to_string(), RefOr::T(Response::new("response1"))),
-            ("response2".to_string(), RefOr::T(Response::new("response2"))),
+            (
+                "response1".to_string(),
+                RefOr::T(Response::new("response1")),
+            ),
+            (
+                "response2".to_string(),
+                RefOr::T(Response::new("response2")),
+            ),
         ]));
 
         let actual = Responses::from(input);
@@ -273,8 +300,14 @@ mod tests {
         ];
 
         let expected = Responses(BTreeMap::from([
-            ("response1".to_string(), RefOr::T(Response::new("response1"))),
-            ("response2".to_string(), RefOr::T(Response::new("response2"))),
+            (
+                "response1".to_string(),
+                RefOr::T(Response::new("response1")),
+            ),
+            (
+                "response2".to_string(),
+                RefOr::T(Response::new("response2")),
+            ),
         ]));
 
         let actual = Responses::from_iter(input);
@@ -292,8 +325,14 @@ mod tests {
     #[test]
     fn test_btree_map_from_responses() {
         let expected = BTreeMap::from([
-            ("response1".to_string(), RefOr::T(Response::new("response1"))),
-            ("response2".to_string(), RefOr::T(Response::new("response2"))),
+            (
+                "response1".to_string(),
+                RefOr::T(Response::new("response1")),
+            ),
+            (
+                "response2".to_string(),
+                RefOr::T(Response::new("response2")),
+            ),
         ]);
 
         let actual = BTreeMap::from(
diff --git a/crates/oapi/src/openapi/schema/all_of.rs b/crates/oapi/src/openapi/schema/all_of.rs
index 75d4a90b2..b546d9d5c 100644
--- a/crates/oapi/src/openapi/schema/all_of.rs
+++ b/crates/oapi/src/openapi/schema/all_of.rs
@@ -226,7 +226,9 @@ mod tests {
     #[test]
     fn test_allof_with_extensions() {
         let expected = json!("value");
-        let json_value = AllOf::new().extensions(Some([("x-some-extension".to_string(), expected.clone())].into()));
+        let json_value = AllOf::new().extensions(Some(
+            [("x-some-extension".to_string(), expected.clone())].into(),
+        ));
 
         let value = serde_json::to_value(&json_value).unwrap();
         assert_eq!(value.get("x-some-extension"), Some(&expected));
diff --git a/crates/oapi/src/openapi/schema/any_of.rs b/crates/oapi/src/openapi/schema/any_of.rs
index b4fb1e12a..459bc13c1 100644
--- a/crates/oapi/src/openapi/schema/any_of.rs
+++ b/crates/oapi/src/openapi/schema/any_of.rs
@@ -226,7 +226,9 @@ mod tests {
     #[test]
     fn test_anyof_with_extensions() {
         let expected = json!("value");
-        let json_value = AnyOf::new().extensions(Some([("x-some-extension".to_string(), expected.clone())].into()));
+        let json_value = AnyOf::new().extensions(Some(
+            [("x-some-extension".to_string(), expected.clone())].into(),
+        ));
 
         let value = serde_json::to_value(&json_value).unwrap();
         assert_eq!(value.get("x-some-extension"), Some(&expected));
diff --git a/crates/oapi/src/openapi/schema/array.rs b/crates/oapi/src/openapi/schema/array.rs
index 598e84ac7..b229ef597 100644
--- a/crates/oapi/src/openapi/schema/array.rs
+++ b/crates/oapi/src/openapi/schema/array.rs
@@ -271,7 +271,9 @@ mod tests {
     #[test]
     fn test_array_with_extensions() {
         let expected = json!("value");
-        let json_value = Array::default().extensions(Some([("x-some-extension".to_string(), expected.clone())].into()));
+        let json_value = Array::default().extensions(Some(
+            [("x-some-extension".to_string(), expected.clone())].into(),
+        ));
 
         let value = serde_json::to_value(&json_value).unwrap();
         assert_eq!(value.get("x-some-extension"), Some(&expected));
diff --git a/crates/oapi/src/openapi/schema/mod.rs b/crates/oapi/src/openapi/schema/mod.rs
index 001da20a8..1c0f434e5 100644
--- a/crates/oapi/src/openapi/schema/mod.rs
+++ b/crates/oapi/src/openapi/schema/mod.rs
@@ -32,7 +32,12 @@ where
     R: Into<RefOr<Schema>>,
 {
     fn from(inner: BTreeMap<K, R>) -> Self {
-        Self(inner.into_iter().map(|(k, v)| (k.into(), v.into())).collect())
+        Self(
+            inner
+                .into_iter()
+                .map(|(k, v)| (k.into(), v.into()))
+                .collect(),
+        )
     }
 }
 impl<K, R, const N: usize> From<[(K, R); N]> for Schemas
@@ -609,7 +614,10 @@ mod tests {
                                     .description("Credential status")
                                     .enum_values(["Active", "NotActive", "Locked", "Expired"]),
                             )
-                            .property("history", Array::new().items(Ref::from_schema_name("UpdateHistory")))
+                            .property(
+                                "history",
+                                Array::new().items(Ref::from_schema_name("UpdateHistory")),
+                            )
                             .property("tags", Object::with_type(BasicType::String).to_array()),
                     ),
                 ),
@@ -639,19 +647,27 @@ mod tests {
             "could not find path: components.schemas.Credential.properties.history"
         );
         assert_json_eq!(
-            credential.get("id").unwrap_or(&serde_json::value::Value::Null),
+            credential
+                .get("id")
+                .unwrap_or(&serde_json::value::Value::Null),
             json!({"type":"integer","format":"int32","description":"Id of credential","default":1})
         );
         assert_json_eq!(
-            credential.get("name").unwrap_or(&serde_json::value::Value::Null),
+            credential
+                .get("name")
+                .unwrap_or(&serde_json::value::Value::Null),
             json!({"type":"string","description":"Name of credential"})
         );
         assert_json_eq!(
-            credential.get("status").unwrap_or(&serde_json::value::Value::Null),
+            credential
+                .get("status")
+                .unwrap_or(&serde_json::value::Value::Null),
             json!({"default":"Active","description":"Credential status","enum":["Active","NotActive","Locked","Expired"],"type":"string"})
         );
         assert_json_eq!(
-            credential.get("history").unwrap_or(&serde_json::value::Value::Null),
+            credential
+                .get("history")
+                .unwrap_or(&serde_json::value::Value::Null),
             json!({"items":{"$ref":"#/components/schemas/UpdateHistory"},"type":"array"})
         );
         assert_eq!(person, &json!({"$ref":"#/components/PersonModel"}));
@@ -685,7 +701,10 @@ mod tests {
                     .description("Credential status")
                     .enum_values(["Active", "NotActive", "Locked", "Expired"]),
             )
-            .property("history", Array::new().items(Ref::from_schema_name("UpdateHistory")))
+            .property(
+                "history",
+                Array::new().items(Ref::from_schema_name("UpdateHistory")),
+            )
             .property("tags", Object::with_type(BasicType::String).to_array());
 
         #[cfg(not(feature = "preserve-order"))]
@@ -704,7 +723,8 @@ mod tests {
     // Examples taken from https://spec.openapis.org/oas/latest.html#model-with-map-dictionary-properties
     #[test]
     fn test_additional_properties() {
-        let json_value = Object::new().additional_properties(Object::new().schema_type(BasicType::String));
+        let json_value =
+            Object::new().additional_properties(Object::new().schema_type(BasicType::String));
         assert_json_eq!(
             json_value,
             json!({
@@ -715,8 +735,9 @@ mod tests {
             })
         );
 
-        let json_value =
-            Object::new().additional_properties(Array::new().items(Object::new().schema_type(BasicType::Number)));
+        let json_value = Object::new().additional_properties(
+            Array::new().items(Object::new().schema_type(BasicType::Number)),
+        );
         assert_json_eq!(
             json_value,
             json!({
@@ -785,7 +806,10 @@ mod tests {
             ),
         );
 
-        assert!(matches!(array.schema_type, SchemaType::Basic(BasicType::Array)));
+        assert!(matches!(
+            array.schema_type,
+            SchemaType::Basic(BasicType::Array)
+        ));
     }
 
     #[test]
@@ -801,7 +825,10 @@ mod tests {
             ),
         );
 
-        assert!(matches!(array.schema_type, SchemaType::Basic(BasicType::Array)));
+        assert!(matches!(
+            array.schema_type,
+            SchemaType::Basic(BasicType::Array)
+        ));
     }
 
     #[test]
@@ -818,11 +845,15 @@ mod tests {
             .response("204", Response::new("No Content"))
             .extend_responses(vec![("200", Response::new("Okay"))])
             .add_security_scheme("TLS", SecurityScheme::MutualTls { description: None })
-            .extend_security_schemes(vec![("APIKey", SecurityScheme::Http(security::Http::default()))]);
+            .extend_security_schemes(vec![(
+                "APIKey",
+                SecurityScheme::Http(security::Http::default()),
+            )]);
 
         let serialized_components = serde_json::to_string(&components).unwrap();
 
-        let deserialized_components: Components = serde_json::from_str(serialized_components.as_str()).unwrap();
+        let deserialized_components: Components =
+            serde_json::from_str(serialized_components.as_str()).unwrap();
 
         assert_eq!(
             serialized_components,
@@ -837,7 +868,8 @@ mod tests {
             .required("name");
 
         let serialized_components = serde_json::to_string(&prop).unwrap();
-        let deserialized_components: Object = serde_json::from_str(serialized_components.as_str()).unwrap();
+        let deserialized_components: Object =
+            serde_json::from_str(serialized_components.as_str()).unwrap();
 
         assert_eq!(
             serialized_components,
@@ -850,7 +882,8 @@ mod tests {
         let prop = Object::new().schema_type(BasicType::String);
 
         let serialized_components = serde_json::to_string(&prop).unwrap();
-        let deserialized_components: Object = serde_json::from_str(serialized_components.as_str()).unwrap();
+        let deserialized_components: Object =
+            serde_json::from_str(serialized_components.as_str()).unwrap();
 
         assert_eq!(
             serialized_components,
@@ -1032,7 +1065,9 @@ mod tests {
     fn serialize_deserialize_schema_with_additional_properties_object() {
         let schema = Schema::Object(Object::new().property(
             "map",
-            Object::new().additional_properties(Object::new().property("name", Object::with_type(BasicType::String))),
+            Object::new().additional_properties(
+                Object::new().property("name", Object::with_type(BasicType::String)),
+            ),
         ));
 
         let json_str = serde_json::to_string(&schema).unwrap();
@@ -1098,7 +1133,8 @@ mod tests {
 
     #[test]
     fn serialize_deserialize_object_with_multiple_schema_types() {
-        let object = Object::new().schema_type(SchemaType::from_iter([BasicType::Object, BasicType::Null]));
+        let object =
+            Object::new().schema_type(SchemaType::from_iter([BasicType::Object, BasicType::Null]));
 
         let json_str = serde_json::to_string(&object).unwrap();
         println!("----------------------------");
@@ -1148,7 +1184,8 @@ mod tests {
 
     #[test]
     fn test_additional_properties_from_ref_or() {
-        let additional_properties = AdditionalProperties::from(RefOr::T(Schema::Object(Object::new())));
+        let additional_properties =
+            AdditionalProperties::from(RefOr::T(Schema::Object(Object::new())));
         assert_json_eq!(
             additional_properties,
             json!({
diff --git a/crates/oapi/src/openapi/schema/object.rs b/crates/oapi/src/openapi/schema/object.rs
index 099bb7bdc..6fa7aa1b7 100644
--- a/crates/oapi/src/openapi/schema/object.rs
+++ b/crates/oapi/src/openapi/schema/object.rs
@@ -188,14 +188,22 @@ impl Object {
     /// Add new property to the [`Object`].
     ///
     /// Method accepts property name and property component as an arguments.
-    pub fn property<S: Into<String>, I: Into<RefOr<Schema>>>(mut self, property_name: S, component: I) -> Self {
-        self.properties.insert(property_name.into(), component.into());
+    pub fn property<S: Into<String>, I: Into<RefOr<Schema>>>(
+        mut self,
+        property_name: S,
+        component: I,
+    ) -> Self {
+        self.properties
+            .insert(property_name.into(), component.into());
 
         self
     }
 
     /// Add additional properties to the [`Object`].
-    pub fn additional_properties<I: Into<AdditionalProperties<Schema>>>(mut self, additional_properties: I) -> Self {
+    pub fn additional_properties<I: Into<AdditionalProperties<Schema>>>(
+        mut self,
+        additional_properties: I,
+    ) -> Self {
         self.additional_properties = Some(Box::new(additional_properties.into()));
         self
     }
@@ -236,7 +244,12 @@ impl Object {
         I: IntoIterator<Item = E>,
         E: Into<Value>,
     {
-        self.enum_values = Some(enum_values.into_iter().map(|enum_value| enum_value.into()).collect());
+        self.enum_values = Some(
+            enum_values
+                .into_iter()
+                .map(|enum_value| enum_value.into())
+                .collect(),
+        );
         self
     }
 
@@ -459,7 +472,9 @@ mod tests {
     #[test]
     fn test_object_with_extensions() {
         let expected = json!("value");
-        let json_value = Object::new().extensions(Some([("x-some-extension".to_string(), expected.clone())].into()));
+        let json_value = Object::new().extensions(Some(
+            [("x-some-extension".to_string(), expected.clone())].into(),
+        ));
 
         let value = serde_json::to_value(&json_value).unwrap();
         assert_eq!(value.get("x-some-extension"), Some(&expected));
diff --git a/crates/oapi/src/openapi/schema/one_of.rs b/crates/oapi/src/openapi/schema/one_of.rs
index 3fe05a5cd..066e19f75 100644
--- a/crates/oapi/src/openapi/schema/one_of.rs
+++ b/crates/oapi/src/openapi/schema/one_of.rs
@@ -226,7 +226,9 @@ mod tests {
     #[test]
     fn test_oneof_with_extensions() {
         let expected = json!("value");
-        let json_value = OneOf::new().extensions(Some([("x-some-extension".to_string(), expected.clone())].into()));
+        let json_value = OneOf::new().extensions(Some(
+            [("x-some-extension".to_string(), expected.clone())].into(),
+        ));
 
         let value = serde_json::to_value(&json_value).unwrap();
         assert_eq!(value.get("x-some-extension"), Some(&expected));
diff --git a/crates/oapi/src/openapi/security.rs b/crates/oapi/src/openapi/security.rs
index a59d3951c..aa93af145 100644
--- a/crates/oapi/src/openapi/security.rs
+++ b/crates/oapi/src/openapi/security.rs
@@ -49,7 +49,10 @@ impl SecurityRequirement {
     /// # use salvo_oapi::security::SecurityRequirement;
     /// SecurityRequirement::default();
     /// ```
-    pub fn new<N: Into<String>, S: IntoIterator<Item = I>, I: Into<String>>(name: N, scopes: S) -> Self {
+    pub fn new<N: Into<String>, S: IntoIterator<Item = I>, I: Into<String>>(
+        name: N,
+        scopes: S,
+    ) -> Self {
         Self {
             value: BTreeMap::from_iter(iter::once_with(|| {
                 (
@@ -73,7 +76,11 @@ impl SecurityRequirement {
     /// Accepts name for the security requirement which must match to the name of available [`SecurityScheme`].
     /// Second parameter is [`IntoIterator`] of [`Into<String>`] scopes needed by the [`SecurityRequirement`].
     /// Scopes must match to the ones defined in [`SecurityScheme`].
-    pub fn add<N: Into<String>, S: IntoIterator<Item = I>, I: Into<String>>(mut self, name: N, scopes: S) -> Self {
+    pub fn add<N: Into<String>, S: IntoIterator<Item = I>, I: Into<String>>(
+        mut self,
+        name: N,
+        scopes: S,
+    ) -> Self {
         self.value.insert(
             Into::<String>::into(name),
             scopes.into_iter().map(Into::<String>::into).collect(),
@@ -447,7 +454,10 @@ impl OAuth2 {
     ///    ),
     /// ], "my oauth2 flow");
     /// ```
-    pub fn with_description<I: IntoIterator<Item = Flow>, S: Into<String>>(flows: I, description: S) -> Self {
+    pub fn with_description<I: IntoIterator<Item = Flow>, S: Into<String>>(
+        flows: I,
+        description: S,
+    ) -> Self {
         Self {
             flows: BTreeMap::from_iter(
                 flows
@@ -559,7 +569,11 @@ impl Implicit {
     ///     "https://localhost/refresh-token"
     /// );
     /// ```
-    pub fn with_refresh_url<S: Into<String>>(authorization_url: S, scopes: Scopes, refresh_url: S) -> Self {
+    pub fn with_refresh_url<S: Into<String>>(
+        authorization_url: S,
+        scopes: Scopes,
+        refresh_url: S,
+    ) -> Self {
         Self {
             authorization_url: authorization_url.into(),
             refresh_url: Some(refresh_url.into()),
@@ -617,7 +631,11 @@ impl AuthorizationCode {
     ///     Scopes::new(),
     /// );
     /// ```
-    pub fn new<A: Into<String>, T: Into<String>>(authorization_url: A, token_url: T, scopes: Scopes) -> Self {
+    pub fn new<A: Into<String>, T: Into<String>>(
+        authorization_url: A,
+        token_url: T,
+        scopes: Scopes,
+    ) -> Self {
         Self {
             authorization_url: authorization_url.into(),
             token_url: token_url.into(),
diff --git a/crates/oapi/src/openapi/server.rs b/crates/oapi/src/openapi/server.rs
index a077e428d..18c57dca4 100644
--- a/crates/oapi/src/openapi/server.rs
+++ b/crates/oapi/src/openapi/server.rs
@@ -207,7 +207,11 @@ impl Server {
     ///   `{username}` substitution then the name should be `username`.
     /// * `parameter` Use [`ServerVariable`] to define how the parameter is being substituted
     ///   within the url.
-    pub fn add_variable<N: Into<String>, V: Into<ServerVariable>>(mut self, name: N, variable: V) -> Self {
+    pub fn add_variable<N: Into<String>, V: Into<ServerVariable>>(
+        mut self,
+        name: N,
+        variable: V,
+    ) -> Self {
         self.variables.insert(name.into(), variable.into());
         self
     }
@@ -238,7 +242,11 @@ impl ServerVariables {
         self.0.is_empty()
     }
     /// Inserts a key-value pair into the instance and returns `self`.
-    pub fn server_varible<K: Into<String>, V: Into<ServerVariable>>(mut self, key: K, variable: V) -> Self {
+    pub fn server_varible<K: Into<String>, V: Into<ServerVariable>>(
+        mut self,
+        key: K,
+        variable: V,
+    ) -> Self {
         self.insert(key, variable);
         self
     }
@@ -316,7 +324,10 @@ impl ServerVariable {
     }
 
     /// Add or change possible values used to substitute parameter.
-    pub fn enum_values<I: IntoIterator<Item = V>, V: Into<String>>(mut self, enum_values: I) -> Self {
+    pub fn enum_values<I: IntoIterator<Item = V>, V: Into<String>>(
+        mut self,
+        enum_values: I,
+    ) -> Self {
         self.enum_values = enum_values.into_iter().map(|value| value.into()).collect();
         self
     }
diff --git a/crates/oapi/src/openapi/xml.rs b/crates/oapi/src/openapi/xml.rs
index c1b495b8a..bcac34402 100644
--- a/crates/oapi/src/openapi/xml.rs
+++ b/crates/oapi/src/openapi/xml.rs
@@ -43,7 +43,9 @@ pub struct Xml {
 impl Xml {
     /// Construct a new [`Xml`] object.
     pub fn new() -> Self {
-        Self { ..Default::default() }
+        Self {
+            ..Default::default()
+        }
     }
 }
 
diff --git a/crates/oapi/src/routing.rs b/crates/oapi/src/routing.rs
index 170c2768f..76cdc3bb4 100644
--- a/crates/oapi/src/routing.rs
+++ b/crates/oapi/src/routing.rs
@@ -30,7 +30,9 @@ impl NormNode {
             .expect("failed to lock METADATA_REGISTRY for read");
         if let Some(metadata) = registry.get(&router.id) {
             node.metadata.tags.extend(metadata.tags.iter().cloned());
-            node.metadata.securities.extend(metadata.securities.iter().cloned());
+            node.metadata
+                .securities
+                .extend(metadata.securities.iter().cloned());
         }
 
         let regex = Regex::new(r#"<([^/:>]+)(:[^>]*)?>"#).expect("invalid regex");
@@ -66,7 +68,8 @@ impl NormNode {
         let routers = router.routers();
         if !routers.is_empty() {
             for router in routers {
-                node.children.push(NormNode::new(router, node.metadata.clone()));
+                node.children
+                    .push(NormNode::new(router, node.metadata.clone()));
             }
         }
         node
diff --git a/crates/otel/src/metrics.rs b/crates/otel/src/metrics.rs
index 54253765e..18366d0e4 100644
--- a/crates/otel/src/metrics.rs
+++ b/crates/otel/src/metrics.rs
@@ -35,7 +35,9 @@ impl Metrics {
             duration: meter
                 .f64_histogram("salvo_request_duration_ms")
                 .with_unit("milliseconds")
-                .with_description("request duration histogram (in milliseconds, since start of service)")
+                .with_description(
+                    "request duration histogram (in milliseconds, since start of service)",
+                )
                 .init(),
         }
     }
@@ -43,9 +45,18 @@ impl Metrics {
 
 #[async_trait]
 impl Handler for Metrics {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         let mut labels = Vec::with_capacity(3);
-        labels.push(KeyValue::new(trace::HTTP_REQUEST_METHOD, req.method().to_string()));
+        labels.push(KeyValue::new(
+            trace::HTTP_REQUEST_METHOD,
+            req.method().to_string(),
+        ));
         labels.push(KeyValue::new(trace::URL_FULL, req.uri().to_string()));
 
         let s = Instant::now();
@@ -53,7 +64,10 @@ impl Handler for Metrics {
         let elapsed = s.elapsed();
 
         let status = res.status_code.unwrap_or(StatusCode::NOT_FOUND);
-        labels.push(KeyValue::new(trace::HTTP_RESPONSE_STATUS_CODE, status.as_u16() as i64));
+        labels.push(KeyValue::new(
+            trace::HTTP_RESPONSE_STATUS_CODE,
+            status.as_u16() as i64,
+        ));
         if status.is_client_error() || status.is_server_error() {
             self.error_count.add(1, &labels);
             let msg = if let ResBody::Error(body) = &res.body {
@@ -65,6 +79,7 @@ impl Handler for Metrics {
         }
 
         self.request_count.add(1, &labels);
-        self.duration.record(elapsed.as_secs_f64() * 1000.0, &labels);
+        self.duration
+            .record(elapsed.as_secs_f64() * 1000.0, &labels);
     }
 }
diff --git a/crates/otel/src/tracing.rs b/crates/otel/src/tracing.rs
index 0834d9f1e..21eced0c4 100644
--- a/crates/otel/src/tracing.rs
+++ b/crates/otel/src/tracing.rs
@@ -23,7 +23,13 @@ where
     T: Tracer + Sync + Send + 'static,
     T::Span: Send + Sync + 'static,
 {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         let remote_addr = req.remote_addr().to_string();
 
         //TODO: Will remove after opentelemetry_http updated
@@ -34,16 +40,24 @@ where
             (name, value)
         }));
 
-        let parent_cx = global::get_text_map_propagator(|propagator| propagator.extract(&HeaderExtractor(&headers)));
+        let parent_cx = global::get_text_map_propagator(|propagator| {
+            propagator.extract(&HeaderExtractor(&headers))
+        });
 
         let mut attributes = Vec::new();
-        attributes.push(KeyValue::new(resource::TELEMETRY_SDK_NAME, env!("CARGO_CRATE_NAME")));
+        attributes.push(KeyValue::new(
+            resource::TELEMETRY_SDK_NAME,
+            env!("CARGO_CRATE_NAME"),
+        ));
         attributes.push(KeyValue::new(
             resource::TELEMETRY_SDK_VERSION,
             env!("CARGO_PKG_VERSION"),
         ));
         attributes.push(KeyValue::new(resource::TELEMETRY_SDK_LANGUAGE, "rust"));
-        attributes.push(KeyValue::new(trace::HTTP_REQUEST_METHOD, req.method().to_string()));
+        attributes.push(KeyValue::new(
+            trace::HTTP_REQUEST_METHOD,
+            req.method().to_string(),
+        ));
         attributes.push(KeyValue::new(trace::URL_FULL, req.uri().to_string()));
         attributes.push(KeyValue::new(trace::CLIENT_ADDRESS, remote_addr));
         attributes.push(KeyValue::new(
@@ -71,7 +85,10 @@ where
                 "request.success"
             };
             span.add_event(event.to_string(), vec![]);
-            span.set_attribute(KeyValue::new(trace::HTTP_RESPONSE_STATUS_CODE, status.as_u16() as i64));
+            span.set_attribute(KeyValue::new(
+                trace::HTTP_RESPONSE_STATUS_CODE,
+                status.as_u16() as i64,
+            ));
             if let Some(content_length) = res.headers().typed_get::<headers::ContentLength>() {
                 span.set_attribute(KeyValue::new(
                     attribute::HTTP_RESPONSE_BODY_SIZE,
diff --git a/crates/proxy/src/lib.rs b/crates/proxy/src/lib.rs
index 9fb25b868..cdb0677bd 100644
--- a/crates/proxy/src/lib.rs
+++ b/crates/proxy/src/lib.rs
@@ -219,7 +219,11 @@ where
         &mut self.client
     }
 
-    async fn build_proxied_request(&self, req: &mut Request, depot: &Depot) -> Result<HyperRequest, Error> {
+    async fn build_proxied_request(
+        &self,
+        req: &mut Request,
+        depot: &Depot,
+    ) -> Result<HyperRequest, Error> {
         let upstream = self.upstreams.elect().await.map_err(Error::other)?;
         if upstream.is_empty() {
             tracing::error!("upstreams is empty");
@@ -247,13 +251,18 @@ where
             format!("{}/{}", upstream, rest)
         };
         let forward_url: Uri = TryFrom::try_from(forward_url).map_err(Error::other)?;
-        let mut build = hyper::Request::builder().method(req.method()).uri(&forward_url);
+        let mut build = hyper::Request::builder()
+            .method(req.method())
+            .uri(&forward_url);
         for (key, value) in req.headers() {
             if key != HOST {
                 build = build.header(key, value);
             }
         }
-        if let Some(host) = forward_url.host().and_then(|host| HeaderValue::from_str(host).ok()) {
+        if let Some(host) = forward_url
+            .host()
+            .and_then(|host| HeaderValue::from_str(host).ok())
+        {
             build = build.header(HeaderName::from_static("host"), host);
         }
         // let x_forwarded_for_header_name = "x-forwarded-for";
@@ -285,7 +294,13 @@ where
     U::Error: Into<BoxedError>,
     C: Client,
 {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, _ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        _ctrl: &mut FlowCtrl,
+    ) {
         match self.build_proxied_request(req, depot).await {
             Ok(proxied_request) => {
                 match self
@@ -339,7 +354,10 @@ fn get_upgrade_type(headers: &HeaderMap) -> Option<&str> {
         .unwrap_or(false)
     {
         if let Some(upgrade_value) = headers.get(&UPGRADE) {
-            tracing::debug!("Found upgrade header with value: {:?}", upgrade_value.to_str());
+            tracing::debug!(
+                "Found upgrade header with value: {:?}",
+                upgrade_value.to_str()
+            );
             return upgrade_value.to_str().ok();
         }
     }
diff --git a/crates/rate-limiter/src/lib.rs b/crates/rate-limiter/src/lib.rs
index 038105ae8..2390dc42f 100644
--- a/crates/rate-limiter/src/lib.rs
+++ b/crates/rate-limiter/src/lib.rs
@@ -56,7 +56,11 @@ pub trait RateIssuer: Send + Sync + 'static {
     /// The key is used to identify the rate limit.
     type Key: Hash + Eq + Send + Sync + 'static;
     /// Issue a new key for the request.
-    fn issue(&self, req: &mut Request, depot: &Depot) -> impl Future<Output = Option<Self::Key>> + Send;
+    fn issue(
+        &self,
+        req: &mut Request,
+        depot: &Depot,
+    ) -> impl Future<Output = Option<Self::Key>> + Send;
 }
 impl<F, K> RateIssuer for F
 where
@@ -117,7 +121,11 @@ pub trait RateStore: Send + Sync + 'static {
         Self::Key: Borrow<Q>,
         Q: Hash + Eq + Sync;
     /// Save the guard from the store.
-    fn save_guard(&self, key: Self::Key, guard: Self::Guard) -> impl Future<Output = Result<(), Self::Error>> + Send;
+    fn save_guard(
+        &self,
+        key: Self::Key,
+        guard: Self::Guard,
+    ) -> impl Future<Output = Result<(), Self::Error>> + Send;
 }
 
 /// `RateLimiter` is the main struct to used limit user request.
@@ -168,7 +176,13 @@ where
     P: QuotaGetter<I::Key>,
     I: RateIssuer,
 {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         if self.skipper.skipped(req, depot) {
             return;
         }
@@ -203,15 +217,18 @@ where
         if self.add_headers {
             res.headers_mut().insert(
                 "X-RateLimit-Limit",
-                HeaderValue::from_str(&guard.limit(&quota).await.to_string()).expect("Invalid header value"),
+                HeaderValue::from_str(&guard.limit(&quota).await.to_string())
+                    .expect("Invalid header value"),
             );
             res.headers_mut().insert(
                 "X-RateLimit-Remaining",
-                HeaderValue::from_str(&(guard.remaining(&quota).await).to_string()).expect("Invalid header value"),
+                HeaderValue::from_str(&(guard.remaining(&quota).await).to_string())
+                    .expect("Invalid header value"),
             );
             res.headers_mut().insert(
                 "X-RateLimit-Reset",
-                HeaderValue::from_str(&guard.reset(&quota).await.to_string()).expect("Invalid header value"),
+                HeaderValue::from_str(&guard.reset(&quota).await.to_string())
+                    .expect("Invalid header value"),
             );
         }
         if !verified {
diff --git a/crates/rate-limiter/src/quota.rs b/crates/rate-limiter/src/quota.rs
index d342a8ed5..205259a39 100644
--- a/crates/rate-limiter/src/quota.rs
+++ b/crates/rate-limiter/src/quota.rs
@@ -78,7 +78,11 @@ pub struct CelledQuota {
 impl CelledQuota {
     /// Create new `CelledQuota`.
     pub const fn new(limit: usize, cells: usize, period: Duration) -> Self {
-        Self { limit, cells, period }
+        Self {
+            limit,
+            cells,
+            period,
+        }
     }
 
     /// Sets the limit of the quota per second.
diff --git a/crates/serde-util/src/case.rs b/crates/serde-util/src/case.rs
index 86bef8a28..f1a9973b8 100644
--- a/crates/serde-util/src/case.rs
+++ b/crates/serde-util/src/case.rs
@@ -69,7 +69,13 @@ impl FromStr for RenameRule {
             .join(", ");
         RENAME_RULES
             .into_iter()
-            .find_map(|(case, rule)| if case == rename_all_str { Some(rule) } else { None })
+            .find_map(|(case, rule)| {
+                if case == rename_all_str {
+                    Some(rule)
+                } else {
+                    None
+                }
+            })
             .ok_or_else(|| {
                 Error::new(
                     Span::call_site(),
@@ -98,7 +104,9 @@ impl RenameRule {
             }
             ScreamingSnakeCase => SnakeCase.apply_to_variant(variant).to_ascii_uppercase(),
             KebabCase => SnakeCase.apply_to_variant(variant).replace('_', "-"),
-            ScreamingKebabCase => ScreamingSnakeCase.apply_to_variant(variant).replace('_', "-"),
+            ScreamingKebabCase => ScreamingSnakeCase
+                .apply_to_variant(variant)
+                .replace('_', "-"),
         }
     }
 
@@ -159,7 +167,10 @@ fn rename_variants() {
         assert_eq!(SnakeCase.apply_to_variant(original), snake);
         assert_eq!(ScreamingSnakeCase.apply_to_variant(original), screaming);
         assert_eq!(KebabCase.apply_to_variant(original), kebab);
-        assert_eq!(ScreamingKebabCase.apply_to_variant(original), screaming_kebab);
+        assert_eq!(
+            ScreamingKebabCase.apply_to_variant(original),
+            screaming_kebab
+        );
     }
 }
 
diff --git a/crates/serde-util/src/lib.rs b/crates/serde-util/src/lib.rs
index 1dd460912..1b6e6a24b 100644
--- a/crates/serde-util/src/lib.rs
+++ b/crates/serde-util/src/lib.rs
@@ -16,7 +16,9 @@ fn parse_next_lit_str(next: Cursor) -> Option<(String, Span)> {
     match next.token_tree() {
         Some((tt, next)) => match tt {
             TokenTree::Punct(punct) if punct.as_char() == '=' => parse_next_lit_str(next),
-            TokenTree::Literal(literal) => Some((literal.to_string().replace('\"', ""), literal.span())),
+            TokenTree::Literal(literal) => {
+                Some((literal.to_string().replace('\"', ""), literal.span()))
+            }
             _ => None,
         },
         _ => None,
@@ -49,11 +51,15 @@ impl SerdeValue {
             while let Some((tt, next)) = rest.token_tree() {
                 match tt {
                     TokenTree::Ident(ident)
-                        if ident == "skip" || ident == "skip_serializing" || ident == "skip_deserializing" =>
+                        if ident == "skip"
+                            || ident == "skip_serializing"
+                            || ident == "skip_deserializing" =>
                     {
                         value.skip = true
                     }
-                    TokenTree::Ident(ident) if ident == "skip_serializing_if" => value.skip_serializing_if = true,
+                    TokenTree::Ident(ident) if ident == "skip_serializing_if" => {
+                        value.skip_serializing_if = true
+                    }
                     TokenTree::Ident(ident) if ident == "flatten" => value.flatten = true,
                     TokenTree::Ident(ident) if ident == "rename" => {
                         if let Some((literal, _)) = parse_next_lit_str(next) {
@@ -139,12 +145,17 @@ impl SerdeContainer {
             "tag" => {
                 if let Some((literal, span)) = parse_next_lit_str(next) {
                     self.enum_repr = match &self.enum_repr {
-                        SerdeEnumRepr::ExternallyTagged => SerdeEnumRepr::InternallyTagged { tag: literal },
-                        SerdeEnumRepr::UnfinishedAdjacentlyTagged { content } => SerdeEnumRepr::AdjacentlyTagged {
-                            tag: literal,
-                            content: content.clone(),
-                        },
-                        SerdeEnumRepr::InternallyTagged { .. } | SerdeEnumRepr::AdjacentlyTagged { .. } => {
+                        SerdeEnumRepr::ExternallyTagged => {
+                            SerdeEnumRepr::InternallyTagged { tag: literal }
+                        }
+                        SerdeEnumRepr::UnfinishedAdjacentlyTagged { content } => {
+                            SerdeEnumRepr::AdjacentlyTagged {
+                                tag: literal,
+                                content: content.clone(),
+                            }
+                        }
+                        SerdeEnumRepr::InternallyTagged { .. }
+                        | SerdeEnumRepr::AdjacentlyTagged { .. } => {
                             return Err(Error::new(span, "Duplicate serde tag argument"));
                         }
                         SerdeEnumRepr::Untagged => {
@@ -156,14 +167,17 @@ impl SerdeContainer {
             "content" => {
                 if let Some((literal, span)) = parse_next_lit_str(next) {
                     self.enum_repr = match &self.enum_repr {
-                        SerdeEnumRepr::InternallyTagged { tag } => SerdeEnumRepr::AdjacentlyTagged {
-                            tag: tag.clone(),
-                            content: literal,
-                        },
+                        SerdeEnumRepr::InternallyTagged { tag } => {
+                            SerdeEnumRepr::AdjacentlyTagged {
+                                tag: tag.clone(),
+                                content: literal,
+                            }
+                        }
                         SerdeEnumRepr::ExternallyTagged => {
                             SerdeEnumRepr::UnfinishedAdjacentlyTagged { content: literal }
                         }
-                        SerdeEnumRepr::AdjacentlyTagged { .. } | SerdeEnumRepr::UnfinishedAdjacentlyTagged { .. } => {
+                        SerdeEnumRepr::AdjacentlyTagged { .. }
+                        | SerdeEnumRepr::UnfinishedAdjacentlyTagged { .. } => {
                             return Err(Error::new(span, "Duplicate serde content argument"));
                         }
                         SerdeEnumRepr::Untagged => {
diff --git a/crates/serve-static/src/dir.rs b/crates/serve-static/src/dir.rs
index 0d9b3beea..a6eb39ab7 100644
--- a/crates/serve-static/src/dir.rs
+++ b/crates/serve-static/src/dir.rs
@@ -18,7 +18,9 @@ use serde::{Deserialize, Serialize};
 use serde_json::json;
 use time::{macros::format_description, OffsetDateTime};
 
-use super::{decode_url_path_safely, encode_url_path, format_url_path_safely, join_path, redirect_to_dir_url};
+use super::{
+    decode_url_path_safely, encode_url_path, format_url_path_safely, join_path, redirect_to_dir_url,
+};
 
 /// CompressionAlgo
 #[derive(Eq, PartialEq, Clone, Copy, Debug, Hash)]
@@ -202,8 +204,10 @@ impl StaticDir {
     where
         A: Into<CompressionAlgo>,
     {
-        self.compressed_variations
-            .insert(algo.into(), exts.split(',').map(|s| s.trim().to_string()).collect());
+        self.compressed_variations.insert(
+            algo.into(),
+            exts.split(',').map(|s| s.trim().to_string()).collect(),
+        );
         self
     }
 
@@ -266,7 +270,10 @@ impl FileInfo {
         FileInfo {
             name,
             size: metadata.len(),
-            modified: metadata.modified().unwrap_or_else(|_| SystemTime::now()).into(),
+            modified: metadata
+                .modified()
+                .unwrap_or_else(|_| SystemTime::now())
+                .into(),
         }
     }
 }
@@ -280,14 +287,23 @@ impl DirInfo {
     fn new(name: String, metadata: Metadata) -> DirInfo {
         DirInfo {
             name,
-            modified: metadata.modified().unwrap_or_else(|_| SystemTime::now()).into(),
+            modified: metadata
+                .modified()
+                .unwrap_or_else(|_| SystemTime::now())
+                .into(),
         }
     }
 }
 
 #[async_trait]
 impl Handler for StaticDir {
-    async fn handle(&self, req: &mut Request, _depot: &mut Depot, res: &mut Response, _ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        _depot: &mut Depot,
+        res: &mut Response,
+        _ctrl: &mut FlowCtrl,
+    ) {
         let req_path = req.uri().path();
         let rel_path = if let Some(rest) = req.params().tail() {
             rest
@@ -363,8 +379,14 @@ impl Handler for StaticDir {
         };
 
         if abs_path.is_file() {
-            let ext = abs_path.extension().and_then(|s| s.to_str()).map(|s| s.to_lowercase());
-            let is_compressed_ext = ext.as_deref().map(|ext| self.is_compressed_ext(ext)).unwrap_or(false);
+            let ext = abs_path
+                .extension()
+                .and_then(|s| s.to_str())
+                .map(|s| s.to_lowercase());
+            let is_compressed_ext = ext
+                .as_deref()
+                .map(|ext| self.is_compressed_ext(ext))
+                .unwrap_or(false);
             let mut content_encoding = None;
             let named_path = if !is_compressed_ext {
                 if !self.compressed_variations.is_empty() {
@@ -406,8 +428,10 @@ impl Handler for StaticDir {
             };
 
             let builder = {
-                let mut builder = NamedFile::builder(named_path)
-                    .content_type(mime_infer::from_ext(ext.as_deref().unwrap_or_default()).first_or_octet_stream());
+                let mut builder = NamedFile::builder(named_path).content_type(
+                    mime_infer::from_ext(ext.as_deref().unwrap_or_default())
+                        .first_or_octet_stream(),
+                );
                 if let Some(content_encoding) = content_encoding {
                     builder = builder.content_encoding(content_encoding);
                 }
@@ -522,7 +546,10 @@ fn human_size(bytes: u64) -> String {
 }
 fn list_html(current: &CurrentInfo) -> String {
     fn header_links(path: &str) -> String {
-        let segments = path.trim_start_matches('/').trim_end_matches('/').split('/');
+        let segments = path
+            .trim_start_matches('/')
+            .trim_end_matches('/')
+            .split('/');
         let mut link = "".to_string();
         format!(
             r#"<a href="/">{}</a>{}"#,
@@ -553,7 +580,11 @@ fn list_html(current: &CurrentInfo) -> String {
         if !(current.path.is_empty() || current.path == "/") {
             write!(ftxt, "<a href=\"../\">[..]</a>").ok();
         }
-        write!(ftxt, "</th><th>Name</th><th>Last modified</th><th>Size</th></tr>").ok();
+        write!(
+            ftxt,
+            "</th><th>Name</th><th>Last modified</th><th>Size</th></tr>"
+        )
+        .ok();
         let format = format_description!("[year]-[month]-[day] [hour]:[minute]:[second]");
         for dir in &current.dirs {
             write!(
diff --git a/crates/serve-static/src/file.rs b/crates/serve-static/src/file.rs
index 8f3ea2c64..6e55c9d52 100644
--- a/crates/serve-static/src/file.rs
+++ b/crates/serve-static/src/file.rs
@@ -30,7 +30,13 @@ impl StaticFile {
 #[async_trait]
 impl Handler for StaticFile {
     #[inline]
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         match self.0.clone().build().await {
             Ok(file) => file.write(req, depot, res).await,
             Err(_) => {
diff --git a/crates/serve-static/src/lib.rs b/crates/serve-static/src/lib.rs
index 09b7d8497..7d5230336 100644
--- a/crates/serve-static/src/lib.rs
+++ b/crates/serve-static/src/lib.rs
@@ -130,13 +130,21 @@ mod tests {
         assert!(content.contains("test3.txt") && content.contains("dir2"));
 
         let content = access(&service, "text/xml", "http://127.0.0.1:5801/dir1/").await;
-        assert!(content.starts_with("<list>") && content.contains("test3.txt") && content.contains("dir2"));
+        assert!(
+            content.starts_with("<list>")
+                && content.contains("test3.txt")
+                && content.contains("dir2")
+        );
 
         let content = access(&service, "text/html", "http://127.0.0.1:5801/dir1/").await;
-        assert!(content.contains("<html>") && content.contains("test3.txt") && content.contains("dir2"));
+        assert!(
+            content.contains("<html>") && content.contains("test3.txt") && content.contains("dir2")
+        );
 
         let content = access(&service, "application/json", "http://127.0.0.1:5801/dir1/").await;
-        assert!(content.starts_with('{') && content.contains("test3.txt") && content.contains("dir2"));
+        assert!(
+            content.starts_with('{') && content.contains("test3.txt") && content.contains("dir2")
+        );
 
         let content = access(&service, "text/plain", "http://127.0.0.1:5801/test1.txt").await;
         assert!(content.contains("copy1"));
@@ -144,16 +152,41 @@ mod tests {
         let content = access(&service, "text/plain", "http://127.0.0.1:5801/test3.txt").await;
         assert!(content.contains("Not Found"));
 
-        let content = access(&service, "text/plain", "http://127.0.0.1:5801/../girl/love/eat.txt").await;
+        let content = access(
+            &service,
+            "text/plain",
+            "http://127.0.0.1:5801/../girl/love/eat.txt",
+        )
+        .await;
         assert!(content.contains("Not Found"));
-        let content = access(&service, "text/plain", "http://127.0.0.1:5801/..\\girl\\love\\eat.txt").await;
+        let content = access(
+            &service,
+            "text/plain",
+            "http://127.0.0.1:5801/..\\girl\\love\\eat.txt",
+        )
+        .await;
         assert!(content.contains("Not Found"));
 
-        let content = access(&service, "text/plain", "http://127.0.0.1:5801/dir1/test3.txt").await;
+        let content = access(
+            &service,
+            "text/plain",
+            "http://127.0.0.1:5801/dir1/test3.txt",
+        )
+        .await;
         assert!(content.contains("copy3"));
-        let content = access(&service, "text/plain", "http://127.0.0.1:5801/dir1/dir2/test3.txt").await;
+        let content = access(
+            &service,
+            "text/plain",
+            "http://127.0.0.1:5801/dir1/dir2/test3.txt",
+        )
+        .await;
         assert!(content == "dir2 test3");
-        let content = access(&service, "text/plain", "http://127.0.0.1:5801/dir1/../dir1/test3.txt").await;
+        let content = access(
+            &service,
+            "text/plain",
+            "http://127.0.0.1:5801/dir1/../dir1/test3.txt",
+        )
+        .await;
         assert!(content == "copy3");
         let content = access(
             &service,
@@ -167,11 +200,18 @@ mod tests {
     #[tokio::test]
     async fn test_serve_static_file() {
         let router = Router::new()
-            .push(Router::with_path("test1.txt").get(StaticFile::new("test/static/test1.txt").chunk_size(1024)))
-            .push(Router::with_path("notexist.txt").get(StaticFile::new("test/static/notexist.txt")));
+            .push(
+                Router::with_path("test1.txt")
+                    .get(StaticFile::new("test/static/test1.txt").chunk_size(1024)),
+            )
+            .push(
+                Router::with_path("notexist.txt").get(StaticFile::new("test/static/notexist.txt")),
+            );
         let service = Service::new(router);
 
-        let mut response = TestClient::get("http://127.0.0.1:5801/test1.txt").send(&service).await;
+        let mut response = TestClient::get("http://127.0.0.1:5801/test1.txt")
+            .send(&service)
+            .await;
         assert_eq!(response.status_code.unwrap(), StatusCode::OK);
         assert_eq!(response.take_string().await.unwrap(), "copy1");
 
@@ -189,7 +229,10 @@ mod tests {
         struct Assets;
 
         let router = Router::new()
-            .push(Router::with_path("test1.txt").get(Assets::get("test1.txt").unwrap().into_handler()))
+            .push(
+                Router::with_path("test1.txt")
+                    .get(Assets::get("test1.txt").unwrap().into_handler()),
+            )
             .push(Router::with_path("files/<**path>").get(serve_file))
             .push(
                 Router::with_path("dir/<**path>").get(
@@ -199,7 +242,10 @@ mod tests {
                 ),
             )
             .push(Router::with_path("dir2/<**path>").get(static_embed::<Assets>()))
-            .push(Router::with_path("dir3/<**path>").get(static_embed::<Assets>().fallback("notexist.html")));
+            .push(
+                Router::with_path("dir3/<**path>")
+                    .get(static_embed::<Assets>().fallback("notexist.html")),
+            );
         let service = Service::new(router);
 
         #[handler]
@@ -226,16 +272,26 @@ mod tests {
             .send(&service)
             .await;
         assert_eq!(response.status_code.unwrap(), StatusCode::OK);
-        assert!(response.take_string().await.unwrap().contains("Fallback page"));
+        assert!(response
+            .take_string()
+            .await
+            .unwrap()
+            .contains("Fallback page"));
 
-        let response = TestClient::get("http://127.0.0.1:5801/dir").send(&service).await;
+        let response = TestClient::get("http://127.0.0.1:5801/dir")
+            .send(&service)
+            .await;
         assert_eq!(response.status_code.unwrap(), StatusCode::OK);
 
-        let mut response = TestClient::get("http://127.0.0.1:5801/dir/").send(&service).await;
+        let mut response = TestClient::get("http://127.0.0.1:5801/dir/")
+            .send(&service)
+            .await;
         assert_eq!(response.status_code.unwrap(), StatusCode::OK);
         assert!(response.take_string().await.unwrap().contains("Index page"));
 
-        let response = TestClient::get("http://127.0.0.1:5801/dir2/").send(&service).await;
+        let response = TestClient::get("http://127.0.0.1:5801/dir2/")
+            .send(&service)
+            .await;
         assert_eq!(response.status_code.unwrap(), StatusCode::NOT_FOUND);
 
         let response = TestClient::get("http://127.0.0.1:5801/dir3/abc.txt")
diff --git a/crates/session/src/lib.rs b/crates/session/src/lib.rs
index a8910756d..e2eeaee73 100644
--- a/crates/session/src/lib.rs
+++ b/crates/session/src/lib.rs
@@ -254,8 +254,8 @@ where
             key,
             fallback_keys,
         } = self;
-        let hmac =
-            Hmac::<Sha256>::new_from_slice(key.signing()).map_err(|_| Error::Other("invalid key length".into()))?;
+        let hmac = Hmac::<Sha256>::new_from_slice(key.signing())
+            .map_err(|_| Error::Other("invalid key length".into()))?;
         let fallback_hmacs = fallback_keys
             .iter()
             .map(|key| Hmac::<Sha256>::new_from_slice(key.signing()))
@@ -308,7 +308,13 @@ impl<S> Handler for SessionHandler<S>
 where
     S: SessionStore,
 {
-    async fn handle(&self, req: &mut Request, depot: &mut Depot, res: &mut Response, ctrl: &mut FlowCtrl) {
+    async fn handle(
+        &self,
+        req: &mut Request,
+        depot: &mut Depot,
+        res: &mut Response,
+        ctrl: &mut FlowCtrl,
+    ) {
         let cookie = req.cookies().get(&self.cookie_name);
         let cookie_value = cookie.and_then(|cookie| self.verify_signature(cookie.value()).ok());
 
@@ -363,7 +369,9 @@ where
             None => None,
         };
 
-        session.and_then(|session| session.validate()).unwrap_or_default()
+        session
+            .and_then(|session| session.validate())
+            .unwrap_or_default()
     }
     // the following is reused verbatim from
     // https://github.com/SergioBenitez/cookie-rs/blob/master/src/secure/signed.rs#L51-L66
@@ -372,12 +380,15 @@ where
     /// an `Err` with a string describing the issue.
     fn verify_signature(&self, cookie_value: &str) -> Result<String, Error> {
         if cookie_value.len() < BASE64_DIGEST_LEN {
-            return Err(Error::Other("length of value is <= BASE64_DIGEST_LEN".into()));
+            return Err(Error::Other(
+                "length of value is <= BASE64_DIGEST_LEN".into(),
+            ));
         }
 
         // Split [MAC | original-value] into its two parts.
         let (digest_str, value) = cookie_value.split_at(BASE64_DIGEST_LEN);
-        let digest = base64::decode(digest_str).map_err(|_| Error::Other("bad base64 digest".into()))?;
+        let digest =
+            base64::decode(digest_str).map_err(|_| Error::Other("bad base64 digest".into()))?;
 
         // Perform the verification.
         let mut hmac = self.hmac.clone();
@@ -521,10 +532,14 @@ mod tests {
             .await;
         assert_eq!(respone.take_string().await.unwrap(), "salvo");
 
-        let respone = TestClient::get("http://127.0.0.1:5800/logout").send(&service).await;
+        let respone = TestClient::get("http://127.0.0.1:5800/logout")
+            .send(&service)
+            .await;
         assert_eq!(respone.status_code, Some(StatusCode::SEE_OTHER));
 
-        let mut respone = TestClient::get("http://127.0.0.1:5800/").send(&service).await;
+        let mut respone = TestClient::get("http://127.0.0.1:5800/")
+            .send(&service)
+            .await;
         assert_eq!(respone.take_string().await.unwrap(), "home");
     }
 }
diff --git a/examples/cache-simple/src/main.rs b/examples/cache-simple/src/main.rs
index 44b1bb5dc..d3d22af3c 100644
--- a/examples/cache-simple/src/main.rs
+++ b/examples/cache-simple/src/main.rs
@@ -11,11 +11,17 @@ async fn home() -> Text<&'static str> {
 }
 #[handler]
 async fn short() -> String {
-    format!("Hello World, my birth time is {}", OffsetDateTime::now_utc())
+    format!(
+        "Hello World, my birth time is {}",
+        OffsetDateTime::now_utc()
+    )
 }
 #[handler]
 async fn long() -> String {
-    format!("Hello World, my birth time is {}", OffsetDateTime::now_utc())
+    format!(
+        "Hello World, my birth time is {}",
+        OffsetDateTime::now_utc()
+    )
 }
 
 #[tokio::main]
@@ -23,11 +29,15 @@ async fn main() {
     tracing_subscriber::fmt().init();
 
     let short_cache = Cache::new(
-        MokaStore::builder().time_to_live(Duration::from_secs(5)).build(),
+        MokaStore::builder()
+            .time_to_live(Duration::from_secs(5))
+            .build(),
         RequestIssuer::default(),
     );
     let long_cache = Cache::new(
-        MokaStore::builder().time_to_live(Duration::from_secs(60)).build(),
+        MokaStore::builder()
+            .time_to_live(Duration::from_secs(60))
+            .build(),
         RequestIssuer::default(),
     );
     let router = Router::new()
diff --git a/examples/concurrency-limiter/src/main.rs b/examples/concurrency-limiter/src/main.rs
index b9fea0c96..1b0f395e1 100644
--- a/examples/concurrency-limiter/src/main.rs
+++ b/examples/concurrency-limiter/src/main.rs
@@ -33,7 +33,12 @@ async fn main() {
     create_dir_all("temp").unwrap();
     let router = Router::new()
         .get(index)
-        .push(Router::new().hoop(max_concurrency(1)).path("limited").post(upload))
+        .push(
+            Router::new()
+                .hoop(max_concurrency(1))
+                .path("limited")
+                .post(upload),
+        )
         .push(Router::with_path("unlimit").post(upload));
 
     let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
diff --git a/examples/csrf-cookie-store/src/main.rs b/examples/csrf-cookie-store/src/main.rs
index 1d96a705d..35cc0df27 100644
--- a/examples/csrf-cookie-store/src/main.rs
+++ b/examples/csrf-cookie-store/src/main.rs
@@ -48,8 +48,10 @@ async fn main() {
 
     let bcrypt_csrf = bcrypt_cookie_csrf(form_finder.clone());
     let hmac_csrf = hmac_cookie_csrf(*b"01234567012345670123456701234567", form_finder.clone());
-    let aes_gcm_cookie_csrf = aes_gcm_cookie_csrf(*b"01234567012345670123456701234567", form_finder.clone());
-    let ccp_cookie_csrf = ccp_cookie_csrf(*b"01234567012345670123456701234567", form_finder.clone());
+    let aes_gcm_cookie_csrf =
+        aes_gcm_cookie_csrf(*b"01234567012345670123456701234567", form_finder.clone());
+    let ccp_cookie_csrf =
+        ccp_cookie_csrf(*b"01234567012345670123456701234567", form_finder.clone());
 
     let router = Router::new()
         .get(home)
@@ -59,7 +61,12 @@ async fn main() {
                 .get(get_page)
                 .post(post_page),
         )
-        .push(Router::with_hoop(hmac_csrf).path("hmac").get(get_page).post(post_page))
+        .push(
+            Router::with_hoop(hmac_csrf)
+                .path("hmac")
+                .get(get_page)
+                .post(post_page),
+        )
         .push(
             Router::with_hoop(aes_gcm_cookie_csrf)
                 .path("aes_gcm")
diff --git a/examples/csrf-session-store/src/main.rs b/examples/csrf-session-store/src/main.rs
index 2dec47230..6a1f18605 100644
--- a/examples/csrf-session-store/src/main.rs
+++ b/examples/csrf-session-store/src/main.rs
@@ -48,8 +48,10 @@ async fn main() {
 
     let bcrypt_csrf = bcrypt_session_csrf(form_finder.clone());
     let hmac_csrf = hmac_session_csrf(*b"01234567012345670123456701234567", form_finder.clone());
-    let aes_gcm_session_csrf = aes_gcm_session_csrf(*b"01234567012345670123456701234567", form_finder.clone());
-    let ccp_session_csrf = ccp_session_csrf(*b"01234567012345670123456701234567", form_finder.clone());
+    let aes_gcm_session_csrf =
+        aes_gcm_session_csrf(*b"01234567012345670123456701234567", form_finder.clone());
+    let ccp_session_csrf =
+        ccp_session_csrf(*b"01234567012345670123456701234567", form_finder.clone());
 
     let session_handler = salvo::session::SessionHandler::builder(
         salvo::session::MemoryStore::new(),
@@ -66,7 +68,12 @@ async fn main() {
                 .get(get_page)
                 .post(post_page),
         )
-        .push(Router::with_hoop(hmac_csrf).path("hmac").get(get_page).post(post_page))
+        .push(
+            Router::with_hoop(hmac_csrf)
+                .path("hmac")
+                .get(get_page)
+                .post(post_page),
+        )
         .push(
             Router::with_hoop(aes_gcm_session_csrf)
                 .path("aes_gcm")
diff --git a/examples/custom-error-page/src/main.rs b/examples/custom-error-page/src/main.rs
index d95acdf50..3883f9d01 100644
--- a/examples/custom-error-page/src/main.rs
+++ b/examples/custom-error-page/src/main.rs
@@ -19,7 +19,9 @@ async fn main() {
 }
 
 fn create_service() -> Service {
-    let router = Router::new().get(hello).push(Router::with_path("500").get(error500));
+    let router = Router::new()
+        .get(hello)
+        .push(Router::with_path("500").get(error500));
     Service::new(router).catcher(Catcher::default().hoop(handle404))
 }
 
diff --git a/examples/db-mongodb/src/main.rs b/examples/db-mongodb/src/main.rs
index acfc568df..004c457d7 100644
--- a/examples/db-mongodb/src/main.rs
+++ b/examples/db-mongodb/src/main.rs
@@ -1,7 +1,10 @@
 use std::sync::OnceLock;
 
 use futures::stream::TryStreamExt;
-use mongodb::{bson::doc, bson::oid::ObjectId, bson::Document, options::IndexOptions, Client, Collection, IndexModel};
+use mongodb::{
+    bson::doc, bson::oid::ObjectId, bson::Document, options::IndexOptions, Client, Collection,
+    IndexModel,
+};
 use salvo::prelude::*;
 use serde::{Deserialize, Serialize};
 
@@ -78,7 +81,10 @@ async fn get_user(req: &mut Request, res: &mut Response) {
     let coll_users: Collection<User> = client.database(DB_NAME).collection(COLL_NAME);
 
     let username = req.param::<String>("username").unwrap();
-    match coll_users.find_one(doc! { "username": &username }, None).await {
+    match coll_users
+        .find_one(doc! { "username": &username }, None)
+        .await
+    {
         Ok(Some(user)) => res.render(Json(user)),
         Ok(None) => res.render(format!("No user found with username {username}")),
         Err(e) => res.render(format!("error {e:?}")),
@@ -103,8 +109,11 @@ async fn create_username_index(client: &Client) {
 async fn main() {
     tracing_subscriber::fmt().init();
 
-    let mongodb_uri = std::env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://10.1.1.80:27017".into());
-    let client = Client::with_uri_str(mongodb_uri).await.expect("failed to connect");
+    let mongodb_uri =
+        std::env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://10.1.1.80:27017".into());
+    let client = Client::with_uri_str(mongodb_uri)
+        .await
+        .expect("failed to connect");
     create_username_index(&client).await;
 
     MONGODB_CLIENT.set(client).unwrap();
diff --git a/examples/db-sea-orm/src/main.rs b/examples/db-sea-orm/src/main.rs
index 047074395..3f2c73193 100644
--- a/examples/db-sea-orm/src/main.rs
+++ b/examples/db-sea-orm/src/main.rs
@@ -48,11 +48,16 @@ async fn list(req: &mut Request, depot: &mut Depot) -> Result<Text<String>> {
         .obtain::<AppState>()
         .map_err(|_| StatusError::internal_server_error())?;
     let page = req.query("page").unwrap_or(1);
-    let posts_per_page = req.query("posts_per_page").unwrap_or(DEFAULT_POSTS_PER_PAGE);
+    let posts_per_page = req
+        .query("posts_per_page")
+        .unwrap_or(DEFAULT_POSTS_PER_PAGE);
     let paginator = post::Entity::find()
         .order_by_asc(post::Column::Id)
         .paginate(&state.conn, posts_per_page);
-    let num_pages = paginator.num_pages().await.map_err(|_| StatusError::bad_request())?;
+    let num_pages = paginator
+        .num_pages()
+        .await
+        .map_err(|_| StatusError::bad_request())?;
     let posts = paginator
         .fetch_page(page - 1)
         .await
@@ -171,7 +176,10 @@ async fn main() {
         .push(Router::with_path("new").get(new))
         .push(Router::with_path("<id>").get(edit).post(update))
         .push(Router::with_path("delete/<id>").post(delete))
-        .push(Router::with_path("static/<**>").get(StaticDir::new(concat!(env!("CARGO_MANIFEST_DIR"), "/static"))));
+        .push(Router::with_path("static/<**>").get(StaticDir::new(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/static"
+        ))));
 
     let acceptor = TcpListener::new(&server_url).bind().await;
     Server::new(acceptor).serve(router).await;
diff --git a/examples/db-sea-orm/src/migration/m20220120_000001_create_post_table.rs b/examples/db-sea-orm/src/migration/m20220120_000001_create_post_table.rs
index 0fe969813..8bed56fa1 100644
--- a/examples/db-sea-orm/src/migration/m20220120_000001_create_post_table.rs
+++ b/examples/db-sea-orm/src/migration/m20220120_000001_create_post_table.rs
@@ -26,7 +26,9 @@ impl MigrationTrait for Migration {
     }
 
     async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
-        manager.drop_table(Table::drop().table(Posts::Table).to_owned()).await
+        manager
+            .drop_table(Table::drop().table(Posts::Table).to_owned())
+            .await
     }
 }
 
diff --git a/examples/fuse-attack/src/main.rs b/examples/fuse-attack/src/main.rs
index a83ba5c4f..9084edbcc 100644
--- a/examples/fuse-attack/src/main.rs
+++ b/examples/fuse-attack/src/main.rs
@@ -14,7 +14,9 @@ async fn main() {
     tracing_subscriber::fmt().init();
 
     let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
-    let router = Router::new().get(hello).push(Router::with_path("你好").get(hello_zh));
+    let router = Router::new()
+        .get(hello)
+        .push(Router::with_path("你好").get(hello_zh));
     println!("{:?}", router);
     Server::new(acceptor)
         .fuse_factory(salvo::fuse::flex::FlexFactory::new())
diff --git a/examples/graceful-shutdown/src/main.rs b/examples/graceful-shutdown/src/main.rs
index 483e50352..56816ef33 100644
--- a/examples/graceful-shutdown/src/main.rs
+++ b/examples/graceful-shutdown/src/main.rs
@@ -17,7 +17,9 @@ async fn main() {
 async fn listen_shutdown_signal(handle: ServerHandle) {
     // Wait Shutdown Signal
     let ctrl_c = async {
-        signal::ctrl_c().await.expect("failed to install Ctrl+C handler");
+        signal::ctrl_c()
+            .await
+            .expect("failed to install Ctrl+C handler");
     };
 
     #[cfg(unix)]
diff --git a/examples/hello/src/main.rs b/examples/hello/src/main.rs
index 5e2327ad9..8f2642d97 100644
--- a/examples/hello/src/main.rs
+++ b/examples/hello/src/main.rs
@@ -14,7 +14,9 @@ async fn main() {
     tracing_subscriber::fmt().init();
 
     let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
-    let router = Router::new().get(hello).push(Router::with_path("你好").get(hello_zh));
+    let router = Router::new()
+        .get(hello)
+        .push(Router::with_path("你好").get(hello_zh));
     println!("{:?}", router);
     Server::new(acceptor).serve(router).await;
 }
diff --git a/examples/jwt-auth/src/main.rs b/examples/jwt-auth/src/main.rs
index 2e3acded3..993a41c14 100644
--- a/examples/jwt-auth/src/main.rs
+++ b/examples/jwt-auth/src/main.rs
@@ -17,13 +17,14 @@ pub struct JwtClaims {
 async fn main() {
     tracing_subscriber::fmt().init();
 
-    let auth_handler: JwtAuth<JwtClaims, _> = JwtAuth::new(ConstDecoder::from_secret(SECRET_KEY.as_bytes()))
-        .finders(vec![
-            // Box::new(HeaderFinder::new()),
-            Box::new(QueryFinder::new("jwt_token")),
-            // Box::new(CookieFinder::new("jwt_token")),
-        ])
-        .force_passed(true);
+    let auth_handler: JwtAuth<JwtClaims, _> =
+        JwtAuth::new(ConstDecoder::from_secret(SECRET_KEY.as_bytes()))
+            .finders(vec![
+                // Box::new(HeaderFinder::new()),
+                Box::new(QueryFinder::new("jwt_token")),
+                // Box::new(CookieFinder::new("jwt_token")),
+            ])
+            .force_passed(true);
 
     let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
     Server::new(acceptor)
diff --git a/examples/jwt-clerk/src/main.rs b/examples/jwt-clerk/src/main.rs
index dc61bd285..526ae9452 100644
--- a/examples/jwt-clerk/src/main.rs
+++ b/examples/jwt-clerk/src/main.rs
@@ -25,7 +25,10 @@ async fn main() {
     let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
     let router = Router::new()
         .push(Router::with_hoop(auth_handler).path("welcome").get(welcome))
-        .push(Router::with_path("<**rest>").goal(Proxy::new(vec!["http://localhost:5801"], HyperClient::default())));
+        .push(Router::with_path("<**rest>").goal(Proxy::new(
+            vec!["http://localhost:5801"],
+            HyperClient::default(),
+        )));
     Server::new(acceptor).serve(router).await;
 }
 #[handler]
@@ -33,7 +36,10 @@ async fn welcome(depot: &mut Depot) -> Result<String, StatusError> {
     match depot.jwt_auth_state() {
         JwtAuthState::Authorized => {
             let data = depot.jwt_auth_data::<JwtClaims>().unwrap();
-            Ok(format!("Hi {}, have logged in successfully!", data.claims.sub))
+            Ok(format!(
+                "Hi {}, have logged in successfully!",
+                data.claims.sub
+            ))
         }
         JwtAuthState::Unauthorized => Err(StatusError::unauthorized()),
         _ => Err(StatusError::forbidden()),
diff --git a/examples/jwt-oidc-clerk/src/main.rs b/examples/jwt-oidc-clerk/src/main.rs
index 35aa45dc1..b580fbe6f 100644
--- a/examples/jwt-oidc-clerk/src/main.rs
+++ b/examples/jwt-oidc-clerk/src/main.rs
@@ -25,7 +25,10 @@ async fn main() {
     let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
     let router = Router::new()
         .push(Router::with_hoop(auth_handler).path("welcome").get(welcome))
-        .push(Router::with_path("<**rest>").goal(Proxy::new(vec!["http://localhost:5801"], HyperClient::default())));
+        .push(Router::with_path("<**rest>").goal(Proxy::new(
+            vec!["http://localhost:5801"],
+            HyperClient::default(),
+        )));
     Server::new(acceptor).serve(router).await;
 }
 #[handler]
@@ -33,7 +36,10 @@ async fn welcome(depot: &mut Depot) -> Result<String, StatusError> {
     match depot.jwt_auth_state() {
         JwtAuthState::Authorized => {
             let data = depot.jwt_auth_data::<JwtClaims>().unwrap();
-            Ok(format!("Hi {}, have logged in successfully!", data.claims.sub))
+            Ok(format!(
+                "Hi {}, have logged in successfully!",
+                data.claims.sub
+            ))
         }
         JwtAuthState::Unauthorized => Err(StatusError::unauthorized()),
         _ => Err(StatusError::forbidden()),
diff --git a/examples/logging-otlp/src/main.rs b/examples/logging-otlp/src/main.rs
index feb049f1f..000adfedd 100644
--- a/examples/logging-otlp/src/main.rs
+++ b/examples/logging-otlp/src/main.rs
@@ -69,7 +69,10 @@ fn init_tracer() -> anyhow::Result<Tracer> {
                 .with_id_generator(RandomIdGenerator::default())
                 .with_max_events_per_span(32)
                 .with_max_attributes_per_span(64)
-                .with_resource(Resource::new(vec![KeyValue::new("service.name", "salvo-tracing")])),
+                .with_resource(Resource::new(vec![KeyValue::new(
+                    "service.name",
+                    "salvo-tracing",
+                )])),
         )
         .install_batch(runtime::Tokio)?;
     Ok(tracer)
diff --git a/examples/oapi-todos/src/main.rs b/examples/oapi-todos/src/main.rs
index 793e803a7..b4bfc9f5a 100644
--- a/examples/oapi-todos/src/main.rs
+++ b/examples/oapi-todos/src/main.rs
@@ -30,7 +30,11 @@ async fn main() {
             Router::with_path("todos")
                 .get(list_todos)
                 .post(create_todo)
-                .push(Router::with_path("<id>").patch(update_todo).delete(delete_todo)),
+                .push(
+                    Router::with_path("<id>")
+                        .patch(update_todo)
+                        .delete(delete_todo),
+                ),
         ),
     );
 
@@ -75,7 +79,10 @@ pub async fn index() -> Text<&'static str> {
         ("offset", description = "Offset is an optional query paramter."),
     )
 )]
-pub async fn list_todos(offset: QueryParam<usize, false>, limit: QueryParam<usize, false>) -> Json<Vec<Todo>> {
+pub async fn list_todos(
+    offset: QueryParam<usize, false>,
+    limit: QueryParam<usize, false>,
+) -> Json<Vec<Todo>> {
     let todos = STORE.lock().await;
     let todos: Vec<Todo> = todos
         .clone()
@@ -106,7 +113,10 @@ pub async fn create_todo(req: JsonBody<Todo>) -> Result<StatusCode, StatusError>
 
 /// Update existing todo.
 #[endpoint(tags("todos"), status_codes(200, 404))]
-pub async fn update_todo(id: PathParam<u64>, updated: JsonBody<Todo>) -> Result<StatusCode, StatusError> {
+pub async fn update_todo(
+    id: PathParam<u64>,
+    updated: JsonBody<Todo>,
+) -> Result<StatusCode, StatusError> {
     tracing::debug!(todo = ?updated, id = ?id, "update todo");
     let mut vec = STORE.lock().await;
 
diff --git a/examples/oapi-upload-files/src/main.rs b/examples/oapi-upload-files/src/main.rs
index d0ce91794..4603bf44f 100644
--- a/examples/oapi-upload-files/src/main.rs
+++ b/examples/oapi-upload-files/src/main.rs
@@ -21,7 +21,10 @@ async fn upload(files: FormFiles, res: &mut Response) {
             msgs.push(dest);
         }
     }
-    res.render(Text::Plain(format!("Files uploaded:\n\n{}", msgs.join("\n"))));
+    res.render(Text::Plain(format!(
+        "Files uploaded:\n\n{}",
+        msgs.join("\n")
+    )));
 }
 
 #[tokio::main]
diff --git a/examples/otel-jaeger/src/client.rs b/examples/otel-jaeger/src/client.rs
index fd4cde29d..886b4dd0d 100644
--- a/examples/otel-jaeger/src/client.rs
+++ b/examples/otel-jaeger/src/client.rs
@@ -32,7 +32,10 @@ async fn main() {
     let cx = Context::current_with_span(span);
 
     let req = {
-        let mut req = reqwest::Request::new(Method::GET, Url::from_str("http://localhost:5800/api1").unwrap());
+        let mut req = reqwest::Request::new(
+            Method::GET,
+            Url::from_str("http://localhost:5800/api1").unwrap(),
+        );
         global::get_text_map_propagator(|propagator| {
             propagator.inject_context(&cx, &mut HeaderInjector(req.headers_mut()));
             println!("{:?}", req.headers_mut());
diff --git a/examples/otel-jaeger/src/server1.rs b/examples/otel-jaeger/src/server1.rs
index 533156bd8..c9b5605f1 100644
--- a/examples/otel-jaeger/src/server1.rs
+++ b/examples/otel-jaeger/src/server1.rs
@@ -1,7 +1,9 @@
 use std::str::FromStr;
 use std::sync::Arc;
 
-use opentelemetry::trace::{FutureExt, SpanKind, TraceContextExt, Tracer as _, TracerProvider as _};
+use opentelemetry::trace::{
+    FutureExt, SpanKind, TraceContextExt, Tracer as _, TracerProvider as _,
+};
 use opentelemetry::{global, KeyValue};
 use opentelemetry_http::HeaderInjector;
 use opentelemetry_sdk::trace::{Tracer, TracerProvider};
@@ -17,10 +19,9 @@ fn init_tracer_provider() -> TracerProvider {
     global::set_text_map_propagator(TraceContextPropagator::new());
     opentelemetry_otlp::new_pipeline()
         .tracing()
-        .with_trace_config(
-            opentelemetry_sdk::trace::Config::default()
-                .with_resource(Resource::new(vec![KeyValue::new("service.name", "server1")])),
-        )
+        .with_trace_config(opentelemetry_sdk::trace::Config::default().with_resource(
+            Resource::new(vec![KeyValue::new("service.name", "server1")]),
+        ))
         .with_exporter(opentelemetry_otlp::new_exporter().tonic())
         .install_batch(opentelemetry_sdk::runtime::Tokio)
         .unwrap()
@@ -38,7 +39,10 @@ async fn index(req: &mut Request, depot: &mut Depot) -> String {
 
     let body = std::str::from_utf8(req.payload().await.unwrap()).unwrap();
     let req = {
-        let mut req = reqwest::Request::new(Method::GET, Url::from_str("http://localhost:5801/api2").unwrap());
+        let mut req = reqwest::Request::new(
+            Method::GET,
+            Url::from_str("http://localhost:5801/api2").unwrap(),
+        );
         global::get_text_map_propagator(|propagator| {
             propagator.inject_context(&cx, &mut HeaderInjector(req.headers_mut()))
         });
diff --git a/examples/otel-jaeger/src/server2.rs b/examples/otel-jaeger/src/server2.rs
index 1ff3ba719..99f6a0a12 100644
--- a/examples/otel-jaeger/src/server2.rs
+++ b/examples/otel-jaeger/src/server2.rs
@@ -10,10 +10,9 @@ fn init_tracer_provider() -> TracerProvider {
     global::set_text_map_propagator(TraceContextPropagator::new());
     opentelemetry_otlp::new_pipeline()
         .tracing()
-        .with_trace_config(
-            opentelemetry_sdk::trace::Config::default()
-                .with_resource(Resource::new(vec![KeyValue::new("service.name", "server2")])),
-        )
+        .with_trace_config(opentelemetry_sdk::trace::Config::default().with_resource(
+            Resource::new(vec![KeyValue::new("service.name", "server2")]),
+        ))
         .with_exporter(opentelemetry_otlp::new_exporter().tonic())
         .install_batch(opentelemetry_sdk::runtime::Tokio)
         .unwrap()
@@ -21,7 +20,10 @@ fn init_tracer_provider() -> TracerProvider {
 
 #[handler]
 async fn index(req: &mut Request) -> String {
-    format!("Body: {}", std::str::from_utf8(req.payload().await.unwrap()).unwrap())
+    format!(
+        "Body: {}",
+        std::str::from_utf8(req.payload().await.unwrap()).unwrap()
+    )
 }
 
 #[tokio::main]
diff --git a/examples/proxy-react-app/src/main.rs b/examples/proxy-react-app/src/main.rs
index ec5fe592f..8c67e58a5 100644
--- a/examples/proxy-react-app/src/main.rs
+++ b/examples/proxy-react-app/src/main.rs
@@ -5,7 +5,10 @@ use salvo::proxy::HyperClient;
 async fn main() {
     tracing_subscriber::fmt().init();
 
-    let router = Router::with_path("<**rest>").goal(Proxy::new(vec!["http://localhost:3000"], HyperClient::default()));
+    let router = Router::with_path("<**rest>").goal(Proxy::new(
+        vec!["http://localhost:3000"],
+        HyperClient::default(),
+    ));
     println!("{:?}", router);
 
     let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
diff --git a/examples/proxy-websocket/src/main.rs b/examples/proxy-websocket/src/main.rs
index 847f455a8..3e9c7977c 100644
--- a/examples/proxy-websocket/src/main.rs
+++ b/examples/proxy-websocket/src/main.rs
@@ -5,7 +5,10 @@ use salvo::proxy::HyperClient;
 async fn main() {
     tracing_subscriber::fmt().init();
 
-    let router = Router::with_path("<**rest>").goal(Proxy::new(vec!["http://localhost:5800"], HyperClient::default()));
+    let router = Router::with_path("<**rest>").goal(Proxy::new(
+        vec!["http://localhost:5800"],
+        HyperClient::default(),
+    ));
     println!("{:?}", router);
     tracing::info!("Run `cargo run --bin example-websocket-chat` to start websocket chat server");
     let acceptor = TcpListener::new("0.0.0.0:8888").bind().await;
diff --git a/examples/rate-limiter-dynamic/src/main.rs b/examples/rate-limiter-dynamic/src/main.rs
index 6792cea39..04d33efe1 100644
--- a/examples/rate-limiter-dynamic/src/main.rs
+++ b/examples/rate-limiter-dynamic/src/main.rs
@@ -4,7 +4,9 @@ use std::hash::Hash;
 use std::sync::LazyLock;
 
 use salvo::prelude::*;
-use salvo::rate_limiter::{CelledQuota, MokaStore, QuotaGetter, RateIssuer, RateLimiter, SlidingGuard};
+use salvo::rate_limiter::{
+    CelledQuota, MokaStore, QuotaGetter, RateIssuer, RateLimiter, SlidingGuard,
+};
 use salvo::Error;
 
 static USER_QUOTAS: LazyLock<HashMap<String, CelledQuota>> = LazyLock::new(|| {
@@ -53,7 +55,12 @@ async fn home() -> Text<&'static str> {
 async fn main() {
     tracing_subscriber::fmt().init();
 
-    let limiter = RateLimiter::new(SlidingGuard::new(), MokaStore::new(), UserIssuer, CustomQuotaGetter);
+    let limiter = RateLimiter::new(
+        SlidingGuard::new(),
+        MokaStore::new(),
+        UserIssuer,
+        CustomQuotaGetter,
+    );
     let router = Router::new()
         .get(home)
         .push(Router::with_path("limited").hoop(limiter).get(limited));
diff --git a/examples/remote-addr/src/main.rs b/examples/remote-addr/src/main.rs
index 508e29e96..4150a17b4 100644
--- a/examples/remote-addr/src/main.rs
+++ b/examples/remote-addr/src/main.rs
@@ -2,7 +2,10 @@ use salvo::prelude::*;
 
 #[handler]
 async fn index(req: &mut Request, res: &mut Response) {
-    res.render(Text::Plain(format!("remote address: {:?}", req.remote_addr())));
+    res.render(Text::Plain(format!(
+        "remote address: {:?}",
+        req.remote_addr()
+    )));
 }
 
 #[tokio::main]
diff --git a/examples/routing/src/main.rs b/examples/routing/src/main.rs
index 80b53c7ce..33a8065fc 100644
--- a/examples/routing/src/main.rs
+++ b/examples/routing/src/main.rs
@@ -11,7 +11,11 @@ async fn main() {
             Router::with_path("users")
                 .hoop(auth)
                 .post(create_user)
-                .push(Router::with_path(r"<id:num>").post(update_user).delete(delete_user)),
+                .push(
+                    Router::with_path(r"<id:num>")
+                        .post(update_user)
+                        .delete(delete_user),
+                ),
         )
         .push(
             Router::with_path("users")
diff --git a/examples/sse-chat/src/main.rs b/examples/sse-chat/src/main.rs
index 92d29fcab..8435e34e8 100644
--- a/examples/sse-chat/src/main.rs
+++ b/examples/sse-chat/src/main.rs
@@ -69,7 +69,9 @@ async fn user_connected(res: &mut Response) {
 
     // Convert messages into Server-Sent Events and returns resulting stream.
     let stream = rx.map(|msg| match msg {
-        Message::UserId(my_id) => Ok::<_, salvo::Error>(SseEvent::default().name("user").text(my_id.to_string())),
+        Message::UserId(my_id) => {
+            Ok::<_, salvo::Error>(SseEvent::default().name("user").text(my_id.to_string()))
+        }
         Message::Reply(reply) => Ok(SseEvent::default().text(reply)),
     });
     SseKeepAlive::new(stream).stream(res);
diff --git a/examples/tls-native-tls/src/main.rs b/examples/tls-native-tls/src/main.rs
index f2fa3be1d..c0e2d05ac 100644
--- a/examples/tls-native-tls/src/main.rs
+++ b/examples/tls-native-tls/src/main.rs
@@ -10,12 +10,17 @@ async fn hello(res: &mut Response) {
 
 #[tokio::main]
 async fn main() {
-    tracing_subscriber::fmt().with_max_level(Level::DEBUG).init();
+    tracing_subscriber::fmt()
+        .with_max_level(Level::DEBUG)
+        .init();
 
     let router = Router::new().get(hello);
     let config = NativeTlsConfig::new()
         .pkcs12(include_bytes!("../certs/identity.p12").to_vec())
         .password("mypass");
-    let acceptor = TcpListener::new("0.0.0.0:5800").native_tls(config).bind().await;
+    let acceptor = TcpListener::new("0.0.0.0:5800")
+        .native_tls(config)
+        .bind()
+        .await;
     Server::new(acceptor).serve(router).await;
 }
diff --git a/examples/tls-openssl/src/main.rs b/examples/tls-openssl/src/main.rs
index 4e693d434..1a51ffc55 100644
--- a/examples/tls-openssl/src/main.rs
+++ b/examples/tls-openssl/src/main.rs
@@ -16,6 +16,9 @@ async fn main() {
             .with_cert(include_bytes!("../certs/cert.pem").as_ref())
             .with_key(include_bytes!("../certs/key.pem").as_ref()),
     );
-    let acceptor = TcpListener::new("0.0.0.0:5800").openssl(config).bind().await;
+    let acceptor = TcpListener::new("0.0.0.0:5800")
+        .openssl(config)
+        .bind()
+        .await;
     Server::new(acceptor).serve(router).await;
 }
diff --git a/examples/todos-utoipa/src/main.rs b/examples/todos-utoipa/src/main.rs
index 422d89032..8caab97c6 100644
--- a/examples/todos-utoipa/src/main.rs
+++ b/examples/todos-utoipa/src/main.rs
@@ -67,7 +67,11 @@ pub(crate) fn route() -> Router {
                     .hoop(size_limiter::max_size(1024 * 16))
                     .get(list_todos)
                     .post(create_todo)
-                    .push(Router::with_path("<id>").put(update_todo).delete(delete_todo)),
+                    .push(
+                        Router::with_path("<id>")
+                            .put(update_todo)
+                            .delete(delete_todo),
+                    ),
             ),
         )
         .push(Router::with_path("/api-doc/openapi.json").get(openapi_json))
@@ -92,8 +96,10 @@ pub async fn serve_swagger(req: &mut Request, depot: &mut Depot, res: &mut Respo
     match utoipa_swagger_ui::serve(tail, config.clone()) {
         Ok(swagger_file) => swagger_file
             .map(|file| {
-                res.headers_mut()
-                    .insert(header::CONTENT_TYPE, HeaderValue::from_str(&file.content_type).unwrap());
+                res.headers_mut().insert(
+                    header::CONTENT_TYPE,
+                    HeaderValue::from_str(&file.content_type).unwrap(),
+                );
                 res.body(ResBody::Once(file.bytes.to_vec().into()));
             })
             .unwrap_or_else(|| {
diff --git a/examples/todos/src/main.rs b/examples/todos/src/main.rs
index adb4afa2d..a712f8831 100644
--- a/examples/todos/src/main.rs
+++ b/examples/todos/src/main.rs
@@ -23,7 +23,11 @@ fn route() -> Router {
         .hoop(size_limiter::max_size(1024 * 16))
         .get(list_todos)
         .post(create_todo)
-        .push(Router::with_path("<id>").put(update_todo).delete(delete_todo))
+        .push(
+            Router::with_path("<id>")
+                .put(update_todo)
+                .delete(delete_todo),
+        )
 }
 
 #[handler]
diff --git a/examples/upload-files/src/main.rs b/examples/upload-files/src/main.rs
index 828251998..b7e9a8156 100644
--- a/examples/upload-files/src/main.rs
+++ b/examples/upload-files/src/main.rs
@@ -22,7 +22,10 @@ async fn upload(req: &mut Request, res: &mut Response) {
                 msgs.push(dest);
             }
         }
-        res.render(Text::Plain(format!("Files uploaded:\n\n{}", msgs.join("\n"))));
+        res.render(Text::Plain(format!(
+            "Files uploaded:\n\n{}",
+            msgs.join("\n")
+        )));
     } else {
         res.status_code(StatusCode::BAD_REQUEST);
         res.render(Text::Plain("file not found in request"));
diff --git a/examples/use-depot/src/main.rs b/examples/use-depot/src/main.rs
index b5901cd1c..c6e4fa233 100644
--- a/examples/use-depot/src/main.rs
+++ b/examples/use-depot/src/main.rs
@@ -6,7 +6,10 @@ async fn set_user(depot: &mut Depot) {
 }
 #[handler]
 async fn hello(depot: &mut Depot) -> String {
-    format!("Hello {}", depot.get::<&str>("user").copied().unwrap_or_default())
+    format!(
+        "Hello {}",
+        depot.get::<&str>("user").copied().unwrap_or_default()
+    )
 }
 
 #[tokio::main]
diff --git a/examples/websocket-chat/src/main.rs b/examples/websocket-chat/src/main.rs
index 3af8dba83..04a736b1c 100644
--- a/examples/websocket-chat/src/main.rs
+++ b/examples/websocket-chat/src/main.rs
@@ -31,7 +31,9 @@ async fn main() {
 
 #[handler]
 async fn user_connected(req: &mut Request, res: &mut Response) -> Result<(), StatusError> {
-    WebSocketUpgrade::new().upgrade(req, res, handle_socket).await
+    WebSocketUpgrade::new()
+        .upgrade(req, res, handle_socket)
+        .await
 }
 async fn handle_socket(ws: WebSocket) {
     // Use a counter to assign a new unique ID for this user.
diff --git a/examples/websocket/src/main.rs b/examples/websocket/src/main.rs
index e522c5389..c2521befa 100644
--- a/examples/websocket/src/main.rs
+++ b/examples/websocket/src/main.rs
@@ -38,7 +38,9 @@ async fn index(res: &mut Response) {
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt().init();
-    let router = Router::new().get(index).push(Router::with_path("ws").goal(connect));
+    let router = Router::new()
+        .get(index)
+        .push(Router::with_path("ws").goal(connect));
 
     let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
     Server::new(acceptor).serve(router).await;
diff --git a/examples/webtransport-acme-http01/src/main.rs b/examples/webtransport-acme-http01/src/main.rs
index 58e1e15bd..cfd9bed26 100644
--- a/examples/webtransport-acme-http01/src/main.rs
+++ b/examples/webtransport-acme-http01/src/main.rs
@@ -116,9 +116,12 @@ where
 async fn main() {
     tracing_subscriber::fmt().init();
 
-    let mut router = Router::new().push(Router::with_path("counter").goal(connect)).push(
-        Router::with_path("<*path>").get(StaticDir::new(["webtransport/static", "./static"]).defaults("client.html")),
-    );
+    let mut router = Router::new()
+        .push(Router::with_path("counter").goal(connect))
+        .push(
+            Router::with_path("<*path>")
+                .get(StaticDir::new(["webtransport/static", "./static"]).defaults("client.html")),
+        );
 
     let listener = TcpListener::new("0.0.0.0:443")
         .acme()
diff --git a/examples/webtransport/src/main.rs b/examples/webtransport/src/main.rs
index 1ac49baf5..00e540c63 100644
--- a/examples/webtransport/src/main.rs
+++ b/examples/webtransport/src/main.rs
@@ -120,9 +120,12 @@ async fn main() {
     let cert = include_bytes!("../certs/cert.pem").to_vec();
     let key = include_bytes!("../certs/key.pem").to_vec();
 
-    let router = Router::new().push(Router::with_path("counter").goal(connect)).push(
-        Router::with_path("<*path>").get(StaticDir::new(["webtransport/static", "./static"]).defaults("client.html")),
-    );
+    let router = Router::new()
+        .push(Router::with_path("counter").goal(connect))
+        .push(
+            Router::with_path("<*path>")
+                .get(StaticDir::new(["webtransport/static", "./static"]).defaults("client.html")),
+        );
 
     let config = RustlsConfig::new(Keycert::new().cert(cert.as_slice()).key(key.as_slice()));
     let listener = TcpListener::new(("0.0.0.0", 5800)).rustls(config.clone());
diff --git a/rustfmt.toml b/rustfmt.toml
index 458d4ee77..2fabbe111 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,2 +1,2 @@
-max_width = 120
+# max_width = 120
 reorder_imports = true
\ No newline at end of file