clippy fixes (#64)

Author: Vaiz

crates/rust-mcp-macros/src/utils.rs

@@ -460,8 +460,7 @@ mod tests {
             let ty: syn::Type = syn::parse_str(ty_str).unwrap();
             assert!(
                 !might_be_struct(&ty),
-                "Expected '{}' to be not a struct",
-                ty_str
+                "Expected '{ty_str}' to be not a struct"
             );
         }
     }

crates/rust-mcp-sdk/src/hyper_servers/routes/fallback_routes.rs

@@ -10,6 +10,6 @@ pub fn routes() -> Router {
 pub async fn not_found(uri: Uri) -> (StatusCode, String) {
     (
         StatusCode::INTERNAL_SERVER_ERROR,
-        format!("Server Error!\r\n uri: {}", uri),
+        format!("Server Error!\r\n uri: {uri}"),
     )
 }

crates/rust-mcp-sdk/src/mcp_handlers/mcp_client_handler.rs

@@ -144,7 +144,7 @@ pub trait ClientHandler: Send + Sync + 'static {
         runtime: &dyn McpClient,
     ) -> std::result::Result<(), RpcError> {
         if !runtime.is_shut_down().await {
-            tracing::error!("Process error: {}", error_message);
+            tracing::error!("Process error: {error_message}");
         }
         Ok(())
     }

crates/rust-mcp-sdk/src/mcp_handlers/mcp_client_handler_core.rs

@@ -48,7 +48,7 @@ pub trait ClientHandlerCore: Send + Sync + 'static {
         runtime: &dyn McpClient,
     ) -> std::result::Result<(), RpcError> {
         if !runtime.is_shut_down().await {
-            tracing::error!("Process error: {}", error_message);
+            tracing::error!("Process error: {error_message}");
         }
         Ok(())
     }

crates/rust-mcp-sdk/src/mcp_handlers/mcp_server_handler.rs

@@ -33,7 +33,7 @@ pub trait ServerHandler: Send + Sync + 'static {
     ) -> std::result::Result<InitializeResult, RpcError> {
         runtime
             .set_client_details(initialize_request.params.clone())
-            .map_err(|err| RpcError::internal_error().with_message(format!("{}", err)))?;
+            .map_err(|err| RpcError::internal_error().with_message(format!("{err}")))?;
 
         let mut server_info = runtime.server_info().to_owned();
         // Provide compatibility for clients using older MCP protocol versions.

crates/rust-mcp-sdk/src/mcp_runtimes/client_runtime.rs

@@ -118,7 +118,7 @@ impl McpClient for ClientRuntime {
                                     break;
                                 }
                                 Err(e) => {
-                                    tracing::error!("Error reading from std_err: {}", e);
+                                    tracing::error!("Error reading from std_err: {e}");
                                     break;
                                 }
                             }

crates/rust-mcp-sdk/src/mcp_runtimes/server_runtime/mcp_server_runtime_core.rs

@@ -70,7 +70,7 @@ impl McpServerHandler for RuntimeCoreInternalHandler<Box<dyn ServerHandlerCore>>
             // keep a copy of the InitializeRequestParams which includes client_info and capabilities
             runtime
                 .set_client_details(initialize_request.params.clone())
-                .map_err(|err| RpcError::internal_error().with_message(format!("{}", err)))?;
+                .map_err(|err| RpcError::internal_error().with_message(format!("{err}")))?;
         }
 
         // handle request and get the result

crates/rust-mcp-sdk/src/utils.rs

@@ -21,10 +21,7 @@ use crate::error::{McpSdkError, SdkResult};
 /// assert_eq!(msg, "Server does not support resources (required for resources/list)");
 /// ```
 pub fn format_assertion_message(entity: &str, capability: &str, method_name: &str) -> String {
-    format!(
-        "{} does not support {} (required for {})",
-        entity, capability, method_name
-    )
+    format!("{entity} does not support {capability} (required for {method_name})")
 }
 
 /// Checks if the client and server protocol versions are compatible by ensuring they are equal.

crates/rust-mcp-sdk/tests/test_server_sse.rs

@@ -42,7 +42,7 @@ mod tets_server_sse {
         sleep(Duration::from_millis(750)).await;
 
         let client = Client::new();
-        println!("connecting to : {}", server_endpoint);
+        println!("connecting to : {server_endpoint}");
         // Act: Connect to the SSE endpoint and read the event stream
         let response = client
             .get(server_endpoint)
@@ -105,7 +105,7 @@ mod tets_server_sse {
         sleep(Duration::from_millis(750)).await;
 
         let client = Client::new();
-        println!("connecting to : {}", server_endpoint);
+        println!("connecting to : {server_endpoint}");
         // Act: Connect to the SSE endpoint and read the event stream
         let response = client
             .get(server_endpoint)
@@ -171,7 +171,7 @@ mod tets_server_sse {
         sleep(Duration::from_millis(750)).await;
 
         let client = Client::new();
-        println!("connecting to : {}", server_endpoint);
+        println!("connecting to : {server_endpoint}");
         // Act: Connect to the SSE endpoint and read the event stream
         let response = client
             .get(server_endpoint)

crates/rust-mcp-transport/src/client_sse.rs

@@ -125,11 +125,11 @@ impl ClientSseTransport {
         let mut header_map = HeaderMap::new();
 
         for (key, value) in headers {
-            let header_name = key.parse::<HeaderName>().map_err(|e| {
-                TransportError::InvalidOptions(format!("Invalid header name: {}", e))
-            })?;
+            let header_name = key
+                .parse::<HeaderName>()
+                .map_err(|e| TransportError::InvalidOptions(format!("Invalid header name: {e}")))?;
             let header_value = HeaderValue::from_str(value).map_err(|e| {
-                TransportError::InvalidOptions(format!("Invalid header value: {}", e))
+                TransportError::InvalidOptions(format!("Invalid header value: {e}"))
             })?;
             header_map.insert(header_name, header_value);
         }
@@ -258,7 +258,7 @@ where
                         // trim the trailing \n before making a request
                         let body = String::from_utf8_lossy(&data).trim().to_string();
                           if let Err(e) = http_post(&client_clone, &post_url, body, &custom_headers).await {
-                            tracing::error!("Failed to POST message: {:?}", e);
+                            tracing::error!("Failed to POST message: {e:?}");
                       }
                     },
                     None => break, // Exit if channel is closed