chore: run cargo fmt across the project

src/client.rs

@@ -642,9 +642,7 @@ where
             ReceivedToken::Error(e) => {
                 last_error.get_or_insert(crate::Error::Server(e));
             }
-            ReceivedToken::DoneInProc(ref done)
-                if !done.status().contains(DoneStatus::More) =>
-            {
+            ReceivedToken::DoneInProc(ref done) if !done.status().contains(DoneStatus::More) => {
                 if columns.is_some() {
                     results.push(std::mem::take(&mut current));
                     columns = None;

src/client/prepared.rs

@@ -176,10 +176,7 @@ impl Drop for PreparedStatement {
 }
 
 /// Build the RPC parameter list for `sp_execute`: `[@handle, @P1, @P2, ...]`.
-fn build_execute_params<'a>(
-    handle: PreparedHandle,
-    params: &[&'a dyn ToSql],
-) -> Vec<RpcParam<'a>> {
+fn build_execute_params<'a>(handle: PreparedHandle, params: &[&'a dyn ToSql]) -> Vec<RpcParam<'a>> {
     let mut rpc_params: Vec<RpcParam<'a>> = Vec::with_capacity(params.len() + 1);
     rpc_params.push(RpcParam {
         name: Cow::Borrowed(""),

src/client/rpc_response.rs

@@ -411,8 +411,9 @@ mod tests {
             mk_done_proc_final(),
         ]);
 
-        let (outputs, status, metadata) =
-            collect_rpc_outputs_with_metadata_from_stream(s).await.unwrap();
+        let (outputs, status, metadata) = collect_rpc_outputs_with_metadata_from_stream(s)
+            .await
+            .unwrap();
 
         assert_eq!(outputs.len(), 1);
         assert_eq!(outputs[0].get::<i32>().unwrap(), Some(42));

src/client/tls.rs

@@ -151,7 +151,10 @@ impl<S> TlsPreloginWrapper<S> {
 
     pub fn handshake_complete(&mut self) {
         self.pending_handshake = false;
-        debug_assert!(self.pending_len == 0, "pending TLS handshake data not flushed");
+        debug_assert!(
+            self.pending_len == 0,
+            "pending TLS handshake data not flushed"
+        );
         self.wr_buf.clear();
         self.wr_pos = 0;
         self.pending_len = 0;
@@ -289,10 +292,8 @@ impl<S: AsyncRead + AsyncWrite + Unpin + Send> AsyncWrite for TlsPreloginWrapper
                     inner.wr_buf.len() - inner.wr_pos,
                 );
 
-                let written = ready!(
-                    Pin::new(&mut inner.stream.as_mut().unwrap())
-                        .poll_write(cx, &inner.wr_buf[inner.wr_pos..])
-                )?;
+                let written = ready!(Pin::new(&mut inner.stream.as_mut().unwrap())
+                    .poll_write(cx, &inner.wr_buf[inner.wr_pos..]))?;
 
                 if written == 0 {
                     return Poll::Ready(Err(io::Error::new(

src/lib.rs

@@ -266,8 +266,8 @@ mod result;
 mod row;
 mod tds;
 
-mod sql_browser;
 pub mod server;
+mod sql_browser;
 
 pub use client::{
     AuthMethod, CancellationToken, Client, Config, Cursor, CursorConcurrencyOptions, CursorHandle,
@@ -281,14 +281,14 @@ pub use result::*;
 pub use row::{Column, ColumnType, Row};
 pub use sql_browser::SqlBrowser;
 pub use tds::{
-        codec::{
-        AltMetaDataColumn, BaseMetaDataColumn, BulkLoadRequest, ColumnData, ColumnFlag, Encode,
-        FedAuthInfoOption, FixedLenType, IntoRow, LoginMessage, MetaDataColumn, PreloginMessage,
-        RpcOption, RpcProcId, RpcStatus, DoneStatus, SessionStateEntry, SsVariantInfo,
+    codec::{
+        AltMetaDataColumn, BaseMetaDataColumn, BulkLoadRequest, ColumnData, ColumnFlag, DoneStatus,
+        Encode, FedAuthInfoOption, FixedLenType, IntoRow, LoginMessage, MetaDataColumn,
+        PreloginMessage, RpcOption, RpcProcId, RpcStatus, SessionStateEntry, SsVariantInfo,
         TokenAltMetaData, TokenAltRow, TokenColInfo, TokenColMetaData, TokenColName, TokenDone,
-        TokenEnvChange, TokenError, TokenFedAuthInfo, TokenFeatureExtAck, TokenInfo, TokenLoginAck,
+        TokenEnvChange, TokenError, TokenFeatureExtAck, TokenFedAuthInfo, TokenInfo, TokenLoginAck,
         TokenOrder, TokenReturnValue, TokenRow, TokenSessionState, TokenSspi, TokenTabName,
-        TypeInfo, TypeLength, TvpColumn, TvpData, TvpInfo, UdtData, UdtInfo, VarLenContext,
+        TvpColumn, TvpData, TvpInfo, TypeInfo, TypeLength, UdtData, UdtInfo, VarLenContext,
         VarLenType, VariantData,
     },
     numeric,

src/server/auth/env_provider.rs

@@ -30,7 +30,12 @@ impl Default for DefaultEnvChangeProvider {
 
 impl DefaultEnvChangeProvider {
     pub fn login_ack(&self, login: &LoginMessage<'_>) -> TokenLoginAck {
-        TokenLoginAck::new(1, login.tds_version(), &self.program_name, self.server_version)
+        TokenLoginAck::new(
+            1,
+            login.tds_version(),
+            &self.program_name,
+            self.server_version,
+        )
     }
 
     pub fn env_changes<C>(&self, client: &C, login: &LoginMessage<'_>) -> Vec<TokenEnvChange>

src/server/auth/gssapi.rs

@@ -51,9 +51,7 @@ impl SspiAcceptor for GssapiAcceptor {
 
         let complete = ctx.is_complete();
         let session_user = if complete {
-            ctx.source_name()
-                .ok()
-                .map(|name| name.to_string())
+            ctx.source_name().ok().map(|name| name.to_string())
         } else {
             None
         };
@@ -89,10 +87,7 @@ impl SspiSession for GssapiSession {
         })?;
         let complete = self.ctx.is_complete();
         let session_user = if complete {
-            self.ctx
-                .source_name()
-                .ok()
-                .map(|name| name.to_string())
+            self.ctx.source_name().ok().map(|name| name.to_string())
         } else {
             None
         };

src/server/auth/handler.rs

@@ -17,7 +17,9 @@ use super::builder::AuthBuilder;
 use super::env_provider::DefaultEnvChangeProvider;
 use super::error::AuthError;
 use super::login_info::LoginInfo;
-use super::traits::{EnvChangeProvider, FedAuthValidator, SqlAuthSource, SspiAcceptor, SspiSession, SspiStep};
+use super::traits::{
+    EnvChangeProvider, FedAuthValidator, SqlAuthSource, SspiAcceptor, SspiSession, SspiStep,
+};
 
 /// Maximum number of concurrent pending SSPI authentication sessions.
 const MAX_PENDING_SSPI_SESSIONS: usize = 1000;
@@ -117,15 +119,8 @@ where
             .and_then(|info| info.server())
             .map(|s| s.to_string())
             .unwrap_or_else(|| client.socket_addr().ip().to_string());
-        let token = crate::TokenError::new(
-            err.code,
-            err.state,
-            err.class,
-            err.message,
-            server,
-            "",
-            1,
-        );
+        let token =
+            crate::TokenError::new(err.code, err.state, err.class, err.message, server, "", 1);
         let done = TokenDone::with_status(DoneStatus::Error.into(), 0);
 
         client
@@ -247,23 +242,14 @@ where
             if let Some(token) = message.fed_auth_token() {
                 let Some(validator) = self.fed_auth.as_ref() else {
                     return self
-                        .send_login_error(
-                            client,
-                            Some(&info),
-                            AuthError::login_failed(info.user()),
-                        )
+                        .send_login_error(client, Some(&info), AuthError::login_failed(info.user()))
                         .await;
                 };
 
                 match validator.validate(&info, token).await {
                     Ok(success) => {
                         return self
-                            .finish_login(
-                                client,
-                                &message,
-                                &info,
-                                success.session_user.as_deref(),
-                            )
+                            .finish_login(client, &message, &info, success.session_user.as_deref())
                             .await;
                     }
                     Err(err) => {
@@ -275,11 +261,7 @@ where
             if let Some(initial) = message.integrated_security_bytes() {
                 let Some(acceptor) = self.sspi.as_ref() else {
                     return self
-                        .send_login_error(
-                            client,
-                            Some(&info),
-                            AuthError::login_failed(info.user()),
-                        )
+                        .send_login_error(client, Some(&info), AuthError::login_failed(info.user()))
                         .await;
                 };
 
@@ -333,12 +315,7 @@ where
                 match sql_auth.authenticate(&info, password).await {
                     Ok(success) => {
                         return self
-                            .finish_login(
-                                client,
-                                &message,
-                                &info,
-                                success.session_user.as_deref(),
-                            )
+                            .finish_login(client, &message, &info, success.session_user.as_deref())
                             .await;
                     }
                     Err(err) => {
@@ -348,7 +325,9 @@ where
             }
 
             if self.allow_trust {
-                return self.finish_login(client, &message, &info, info.user()).await;
+                return self
+                    .finish_login(client, &message, &info, info.user())
+                    .await;
             }
 
             self.send_login_error(client, Some(&info), AuthError::login_failed(info.user()))
@@ -373,18 +352,16 @@ where
 
             let Some(mut session) = session else {
                 return self
-                    .send_login_error(
-                        client,
-                        None,
-                        AuthError::login_failed(None),
-                    )
+                    .send_login_error(client, None, AuthError::login_failed(None))
                     .await;
             };
 
             let step = match session.sspi.step(token.as_ref()) {
                 Ok(step) => step,
                 Err(err) => {
-                    return self.send_login_error(client, Some(&session.info), err).await;
+                    return self
+                        .send_login_error(client, Some(&session.info), err)
+                        .await;
                 }
             };
 
@@ -397,8 +374,7 @@ where
                 sessions.insert(addr, session);
             }
 
-            self.handle_sspi_step(client, &login, &info, step)
-                .await
+            self.handle_sspi_step(client, &login, &info, step).await
         })
     }
 }

src/server/auth/login_info.rs

@@ -30,7 +30,11 @@ impl LoginInfo {
         let hostname = login.hostname_ref().trim();
 
         Self {
-            user: if user.is_empty() { None } else { Some(user.to_string()) },
+            user: if user.is_empty() {
+                None
+            } else {
+                Some(user.to_string())
+            },
             database: if database.is_empty() {
                 None
             } else {

src/server/auth/traits.rs

@@ -4,7 +4,7 @@ use std::fmt::Debug;
 
 use async_trait::async_trait;
 
-use crate::tds::codec::{TokenEnvChange, TokenFedAuthInfo, TokenFeatureExtAck, TokenLoginAck};
+use crate::tds::codec::{TokenEnvChange, TokenFeatureExtAck, TokenFedAuthInfo, TokenLoginAck};
 use crate::LoginMessage;
 
 use super::error::{AuthResult, AuthSuccess};

src/server/builder.rs

@@ -138,7 +138,9 @@ pub struct TdsServerBuilder<A, S, R, B, AT, E> {
     error: E,
 }
 
-impl Default for TdsServerBuilder<NotSet, NotSet, RejectRpc, RejectBulkLoad, NoOpAttention, NoOpError> {
+impl Default
+    for TdsServerBuilder<NotSet, NotSet, RejectRpc, RejectBulkLoad, NoOpAttention, NoOpError>
+{
     fn default() -> Self {
         Self::new()
     }
@@ -233,7 +235,10 @@ impl<A, S, R, B, AT, E> TdsServerBuilder<A, S, R, B, AT, E> {
     ///     .auth(my_auth_handler)
     ///     .query(my_query_handler);
     /// ```
-    pub fn query<H>(self, handler: H) -> TdsServerBuilder<A, Set<SimpleQueryAdapter<H>>, R, B, AT, E>
+    pub fn query<H>(
+        self,
+        handler: H,
+    ) -> TdsServerBuilder<A, Set<SimpleQueryAdapter<H>>, R, B, AT, E>
     where
         H: QueryHandler,
     {