spikard 0.8.2 → 0.10.1

data/vendor/crates/spikard-core/src/router.rs

@@ -70,8 +70,8 @@ pub struct JsonRpcMethodInfo {
 
 /// Route definition with compiled validators
 ///
-/// Validators are Arc-wrapped to enable cheap cloning across route instances
-/// and to support schema deduplication via SchemaRegistry.
+/// Validators are `Arc`-wrapped to enable cheap cloning across route instances
+/// and to support schema deduplication via `SchemaRegistry`.
 ///
 /// The `jsonrpc_method` field is optional and has zero overhead when None,
 /// enabling routes to optionally expose themselves as JSON-RPC methods.
@@ -102,10 +102,14 @@ impl Route {
     ///
     /// Auto-generates parameter schema from type hints in the path if no explicit schema provided.
     /// Type hints like `/items/{id:uuid}` generate appropriate JSON Schema validation.
-    /// Explicit parameter_schema overrides auto-generated schemas.
+    /// Explicit `parameter_schema` overrides auto-generated schemas.
+    ///
+    /// # Errors
+    /// Returns an error if the schema compilation fails or metadata is invalid.
     ///
     /// The schema registry ensures each unique schema is compiled only once, improving
     /// startup performance and memory usage for applications with many routes.
+    #[allow(clippy::items_after_statements)]
     pub fn from_metadata(metadata: RouteMetadata, registry: &SchemaRegistry) -> Result<Self, String> {
         let method = metadata.method.parse()?;
 
@@ -135,7 +139,10 @@ impl Route {
                 if is_empty_schema(&explicit_schema) {
                     Some(auto_schema)
                 } else {
-                    Some(crate::type_hints::merge_parameter_schemas(auto_schema, explicit_schema))
+                    Some(crate::type_hints::merge_parameter_schemas(
+                        &auto_schema,
+                        &explicit_schema,
+                    ))
                 }
             }
             (Some(auto_schema), None) => Some(auto_schema),
@@ -187,17 +194,20 @@ impl Route {
     ///         tags: vec!["users".to_string()],
     ///     });
     /// ```
+    #[must_use]
     pub fn with_jsonrpc_method(mut self, info: JsonRpcMethodInfo) -> Self {
         self.jsonrpc_method = Some(info);
         self
     }
 
     /// Check if this route has JSON-RPC metadata
-    pub fn is_jsonrpc_method(&self) -> bool {
+    #[must_use]
+    pub const fn is_jsonrpc_method(&self) -> bool {
         self.jsonrpc_method.is_some()
     }
 
     /// Get the JSON-RPC method name if present
+    #[must_use]
     pub fn jsonrpc_method_name(&self) -> Option<&str> {
         self.jsonrpc_method.as_ref().map(|m| m.method_name.as_str())
     }
@@ -210,6 +220,7 @@ pub struct Router {
 
 impl Router {
     /// Create a new router
+    #[must_use]
     pub fn new() -> Self {
         Self { routes: HashMap::new() }
     }
@@ -221,18 +232,21 @@ impl Router {
     }
 
     /// Find a route by method and path
+    #[must_use]
     pub fn find_route(&self, method: &Method, path: &str) -> Option<&Route> {
         self.routes.get(path)?.get(method)
     }
 
     /// Get all routes
+    #[must_use]
     pub fn routes(&self) -> Vec<&Route> {
         self.routes.values().flat_map(|methods| methods.values()).collect()
     }
 
     /// Get route count
+    #[must_use]
     pub fn route_count(&self) -> usize {
-        self.routes.values().map(|m| m.len()).sum()
+        self.routes.values().map(std::collections::HashMap::len).sum()
     }
 }
 
@@ -264,6 +278,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -298,6 +313,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -330,6 +346,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -346,6 +363,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -424,6 +442,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -497,6 +516,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };

data/vendor/crates/spikard-core/src/schema_registry.rs

@@ -1,9 +1,9 @@
-//! Schema registry for deduplication and OpenAPI generation
+//! Schema registry for deduplication and `OpenAPI` generation
 //!
 //! This module provides a global registry that compiles JSON schemas once at application
 //! startup and reuses them across all routes. This enables:
 //! - Schema deduplication (same schema used by multiple routes)
-//! - OpenAPI spec generation (access to all schemas)
+//! - `OpenAPI` spec generation (access to all schemas)
 //! - Memory efficiency (one compiled validator per unique schema)
 
 use crate::validation::SchemaValidator;
@@ -14,7 +14,7 @@ use std::sync::{Arc, RwLock};
 /// Global schema registry for compiled validators
 ///
 /// Thread-safe registry that ensures each unique schema is compiled exactly once.
-/// Uses RwLock for concurrent read access with occasional writes during startup.
+/// Uses `RwLock` for concurrent read access with occasional writes during startup.
 pub struct SchemaRegistry {
     /// Map from schema JSON string to compiled validator
     schemas: RwLock<HashMap<String, Arc<SchemaValidator>>>,
@@ -22,13 +22,14 @@ pub struct SchemaRegistry {
 
 impl SchemaRegistry {
     /// Create a new empty schema registry
+    #[must_use]
     pub fn new() -> Self {
         Self {
             schemas: RwLock::new(HashMap::new()),
         }
     }
 
-    /// Get or compile a schema, returning Arc to the compiled validator
+    /// Get or compile a schema, returning `Arc` to the compiled validator
     ///
     /// This method is thread-safe and uses a double-check pattern:
     /// 1. Fast path: Read lock to check if schema exists
@@ -38,9 +39,15 @@ impl SchemaRegistry {
     /// * `schema` - The JSON schema to compile
     ///
     /// # Returns
-    /// Arc-wrapped compiled validator that can be cheaply cloned
+    /// `Arc`-wrapped compiled validator that can be cheaply cloned
+    ///
+    /// # Errors
+    /// Returns an error if schema serialization or compilation fails.
+    ///
+    /// # Panics
+    /// Panics if the read or write lock is poisoned.
     pub fn get_or_compile(&self, schema: &Value) -> Result<Arc<SchemaValidator>, String> {
-        let key = serde_json::to_string(schema).map_err(|e| format!("Failed to serialize schema: {}", e))?;
+        let key = serde_json::to_string(schema).map_err(|e| format!("Failed to serialize schema: {e}"))?;
 
         {
             let schemas = self.schemas.read().unwrap();
@@ -62,10 +69,14 @@ impl SchemaRegistry {
         Ok(validator)
     }
 
-    /// Get all registered schemas (for OpenAPI generation)
+    /// Get all registered schemas (for `OpenAPI` generation)
     ///
     /// Returns a snapshot of all compiled validators.
-    /// Useful for generating OpenAPI specifications from runtime schema information.
+    /// Useful for generating `OpenAPI` specifications from runtime schema information.
+    ///
+    /// # Panics
+    /// Panics if the read lock is poisoned.
+    #[must_use]
     pub fn all_schemas(&self) -> Vec<Arc<SchemaValidator>> {
         let schemas = self.schemas.read().unwrap();
         schemas.values().cloned().collect()
@@ -74,6 +85,10 @@ impl SchemaRegistry {
     /// Get the number of unique schemas registered
     ///
     /// Useful for diagnostics and understanding schema deduplication effectiveness.
+    ///
+    /// # Panics
+    /// Panics if the read lock is poisoned.
+    #[must_use]
     pub fn schema_count(&self) -> usize {
         let schemas = self.schemas.read().unwrap();
         schemas.len()
@@ -164,16 +179,15 @@ mod tests {
             }
         });
 
-        let handles: Vec<_> = (0..10)
+        let validators: Vec<_> = (0..10)
             .map(|_| {
                 let registry = StdArc::clone(&registry);
                 let schema = schema.clone();
                 thread::spawn(move || registry.get_or_compile(&schema).unwrap())
             })
+            .map(|h| h.join().unwrap())
             .collect();
 
-        let validators: Vec<_> = handles.into_iter().map(|h| h.join().unwrap()).collect();
-
         for i in 1..validators.len() {
             assert!(Arc::ptr_eq(&validators[0], &validators[i]));
         }

data/vendor/crates/spikard-core/src/type_hints.rs

@@ -39,6 +39,10 @@ fn path_type_regex() -> &'static Regex {
 /// assert_eq!(hints.get("id"), Some(&"uuid".to_string()));
 /// assert_eq!(hints.get("tag_id"), Some(&"int".to_string()));
 /// ```
+///
+/// # Panics
+/// Panics if regex capture groups don't contain expected indices.
+#[must_use]
 pub fn parse_type_hints(route_path: &str) -> HashMap<String, String> {
     let mut hints = HashMap::new();
     let re = type_hint_regex();
@@ -66,6 +70,7 @@ pub fn parse_type_hints(route_path: &str) -> HashMap<String, String> {
 /// assert_eq!(strip_type_hints("/items/{id:uuid}"), "/items/{id}");
 /// assert_eq!(strip_type_hints("/files/{path:path}"), "/files/{*path}");
 /// ```
+#[must_use]
 pub fn strip_type_hints(route_path: &str) -> String {
     let path_re = path_type_regex();
     let route_path = path_re.replace_all(route_path, "{*$1}");
@@ -86,6 +91,8 @@ pub fn strip_type_hints(route_path: &str) -> String {
 /// - `date` → `{"type": "string", "format": "date"}`
 /// - `datetime` → `{"type": "string", "format": "date-time"}`
 /// - `path` → `{"type": "string"}` (wildcard capture)
+#[must_use]
+#[allow(clippy::match_same_arms)]
 pub fn type_hint_to_schema(type_hint: &str) -> Value {
     match type_hint {
         "uuid" => json!({
@@ -95,7 +102,7 @@ pub fn type_hint_to_schema(type_hint: &str) -> Value {
         "int" | "integer" => json!({
             "type": "integer"
         }),
-        "str" | "string" => json!({
+        "str" | "string" | "path" => json!({
             "type": "string"
         }),
         "float" | "number" => json!({
@@ -112,9 +119,6 @@ pub fn type_hint_to_schema(type_hint: &str) -> Value {
             "type": "string",
             "format": "date-time"
         }),
-        "path" => json!({
-            "type": "string"
-        }),
         _ => json!({
             "type": "string"
         }),
@@ -145,6 +149,7 @@ pub fn type_hint_to_schema(type_hint: &str) -> Value {
 ///     "required": ["id"]
 /// })));
 /// ```
+#[must_use]
 pub fn auto_generate_parameter_schema(route_path: &str) -> Option<Value> {
     let type_hints = parse_type_hints(route_path);
 
@@ -201,10 +206,11 @@ pub fn auto_generate_parameter_schema(route_path: &str) -> Option<Value> {
 ///     "required": ["count"]
 /// });
 ///
-/// let merged = merge_parameter_schemas(auto_schema, explicit_schema);
+/// let merged = merge_parameter_schemas(&auto_schema, &explicit_schema);
 /// // Result: auto-generated id + explicit count with constraints
 /// ```
-pub fn merge_parameter_schemas(auto_schema: Value, explicit_schema: Value) -> Value {
+#[must_use]
+pub fn merge_parameter_schemas(auto_schema: &Value, explicit_schema: &Value) -> Value {
     let mut result = auto_schema.clone();
 
     let auto_props = result.get_mut("properties").and_then(|v| v.as_object_mut());
@@ -229,6 +235,7 @@ pub fn merge_parameter_schemas(auto_schema: Value, explicit_schema: Value) -> Va
     result
 }
 
+#[allow(clippy::literal_string_with_formatting_args)]
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -296,7 +303,7 @@ mod tests {
             "required": ["count"]
         });
 
-        let merged = merge_parameter_schemas(auto_schema, explicit_schema);
+        let merged = merge_parameter_schemas(&auto_schema, &explicit_schema);
         assert!(merged["properties"]["id"].is_object());
         assert!(merged["properties"]["count"].is_object());
         assert_eq!(merged["properties"]["count"]["minimum"], 1);

data/vendor/crates/spikard-core/src/validation/error_mapper.rs

@@ -51,31 +51,35 @@ pub enum ErrorCondition {
 
 impl ErrorCondition {
     /// Determine the error condition from schema path and error message
+    #[must_use]
+    #[allow(clippy::ignored_unit_patterns)]
     pub fn from_schema_error(schema_path_str: &str, error_msg: &str) -> Self {
         match () {
-            _ if schema_path_str.contains("minLength") => Self::StringTooShort { min_length: None },
-            _ if schema_path_str.contains("maxLength") => Self::StringTooLong { max_length: None },
-            _ if schema_path_str.contains("exclusiveMinimum")
+            () if schema_path_str.contains("minLength") => Self::StringTooShort { min_length: None },
+            () if schema_path_str.contains("maxLength") => Self::StringTooLong { max_length: None },
+            () if schema_path_str.contains("exclusiveMinimum")
                 || (error_msg.contains("less than or equal to") && error_msg.contains("minimum")) =>
             {
                 Self::GreaterThan { value: None }
             }
-            _ if schema_path_str.contains("minimum") || error_msg.contains("less than the minimum") => {
+            () if schema_path_str.contains("minimum") || error_msg.contains("less than the minimum") => {
                 Self::GreaterThanEqual { value: None }
             }
-            _ if schema_path_str.contains("exclusiveMaximum")
+            () if schema_path_str.contains("exclusiveMaximum")
                 || (error_msg.contains("greater than or equal to") && error_msg.contains("maximum")) =>
             {
                 Self::LessThan { value: None }
             }
-            _ if schema_path_str.contains("maximum") || error_msg.contains("greater than the maximum") => {
+            () if schema_path_str.contains("maximum") || error_msg.contains("greater than the maximum") => {
                 Self::LessThanEqual { value: None }
             }
-            _ if schema_path_str.contains("enum") || error_msg.contains("is not one of") => Self::Enum { values: None },
-            _ if schema_path_str.contains("pattern") || error_msg.contains("does not match") => {
+            () if schema_path_str.contains("enum") || error_msg.contains("is not one of") => {
+                Self::Enum { values: None }
+            }
+            () if schema_path_str.contains("pattern") || error_msg.contains("does not match") => {
                 Self::StringPatternMismatch { pattern: None }
             }
-            _ if schema_path_str.contains("format") => {
+            () if schema_path_str.contains("format") => {
                 if error_msg.contains("email") {
                     Self::EmailFormat
                 } else if error_msg.contains("uuid") {
@@ -104,7 +108,8 @@ impl ErrorCondition {
     }
 
     /// Get the error type code for this condition
-    pub fn error_type(&self) -> &'static str {
+    #[must_use]
+    pub const fn error_type(&self) -> &'static str {
         match self {
             Self::StringTooShort { .. } => "string_too_short",
             Self::StringTooLong { .. } => "string_too_long",
@@ -113,23 +118,22 @@ impl ErrorCondition {
             Self::LessThan { .. } => "less_than",
             Self::LessThanEqual { .. } => "less_than_equal",
             Self::Enum { .. } => "enum",
-            Self::StringPatternMismatch { .. } => "string_pattern_mismatch",
-            Self::EmailFormat => "string_pattern_mismatch",
+            Self::StringPatternMismatch { .. } | Self::EmailFormat => "string_pattern_mismatch",
             Self::UuidFormat => "uuid_parsing",
             Self::DatetimeFormat => "datetime_parsing",
             Self::DateFormat => "date_parsing",
             Self::FormatError => "format_error",
             Self::TypeMismatch { .. } => "type_error",
             Self::Missing => "missing",
-            Self::AdditionalProperties { .. } => "validation_error",
+            Self::AdditionalProperties { .. } | Self::ValidationError => "validation_error",
             Self::TooFewItems { .. } => "too_short",
             Self::TooManyItems => "too_long",
-            Self::ValidationError => "validation_error",
         }
     }
 
     /// Get default message for this error condition
-    pub fn default_message(&self) -> &'static str {
+    #[must_use]
+    pub const fn default_message(&self) -> &'static str {
         match self {
             Self::StringTooShort { .. } => "String is too short",
             Self::StringTooLong { .. } => "String is too long",
@@ -159,6 +163,16 @@ pub struct ErrorMapper;
 
 impl ErrorMapper {
     /// Map an error condition to its type, message, and context
+    ///
+    /// # Panics
+    /// Panics if accessing `.last()` on an empty vector for enum values extraction.
+    #[must_use]
+    #[allow(
+        clippy::too_many_lines,
+        clippy::option_if_let_else,
+        clippy::redundant_closure_for_method_calls,
+        clippy::uninlined_format_args
+    )]
     pub fn map_error(
         condition: &ErrorCondition,
         schema: &Value,
@@ -661,7 +675,7 @@ mod tests {
         let condition = ErrorCondition::EmailFormat;
         let (error_type, msg, ctx) = ErrorMapper::map_error(&condition, &schema, "", "");
         assert_eq!(error_type, "string_pattern_mismatch");
-        assert!(msg.contains("@"));
+        assert!(msg.contains('@'));
         assert!(ctx.is_some());
     }
 

data/vendor/crates/spikard-core/src/validation/mod.rs

@@ -18,6 +18,9 @@ pub struct SchemaValidator {
 
 impl SchemaValidator {
     /// Create a new validator from a JSON Schema
+    ///
+    /// # Errors
+    /// Returns an error if the schema is invalid or compilation fails.
     pub fn new(schema: Value) -> Result<Self, String> {
         let compiled = jsonschema::options()
             .with_draft(jsonschema::Draft::Draft202012)
@@ -26,7 +29,7 @@ impl SchemaValidator {
             .build(&schema)
             .map_err(|e| {
                 anyhow::anyhow!("Invalid JSON Schema")
-                    .context(format!("Schema compilation failed: {}", e))
+                    .context(format!("Schema compilation failed: {e}"))
                     .to_string()
             })?;
 
@@ -37,16 +40,17 @@ impl SchemaValidator {
     }
 
     /// Get the underlying JSON Schema
-    pub fn schema(&self) -> &Value {
+    #[must_use]
+    pub const fn schema(&self) -> &Value {
         &self.schema
     }
 
-    /// Pre-process data to convert file objects to strings for format: "binary" validation
+    /// Pre-process data to convert file objects to strings for format: `binary` validation
     ///
     /// Files uploaded via multipart are converted to objects like:
-    /// {"filename": "...", "size": N, "content": "...", "content_type": "..."}
+    /// `{"filename": "...", "size": N, "content": "...", "content_type": "..."}`
     ///
-    /// But schemas define them as: {"type": "string", "format": "binary"}
+    /// But schemas define them as: `{"type": "string", "format": "binary"}`
     ///
     /// This method recursively processes the data and converts file objects to their content strings
     /// so that validation passes, while preserving the original structure for handlers to use.
@@ -54,7 +58,7 @@ impl SchemaValidator {
         self.preprocess_value_with_schema(data, &self.schema)
     }
 
-    #[allow(clippy::only_used_in_recursion)]
+    #[allow(clippy::only_used_in_recursion, clippy::self_only_used_in_recursion)]
     fn preprocess_value_with_schema(&self, data: &Value, schema: &Value) -> Value {
         if let Some(schema_obj) = schema.as_object() {
             let is_string_type = schema_obj.get("type").and_then(|t| t.as_str()) == Some("string");
@@ -110,6 +114,13 @@ impl SchemaValidator {
     }
 
     /// Validate JSON data against the schema
+    ///
+    /// # Errors
+    /// Returns a `ValidationError` if the data does not conform to the schema.
+    ///
+    /// # Too Many Lines
+    /// This function is complex due to error mapping logic.
+    #[allow(clippy::option_if_let_else, clippy::uninlined_format_args, clippy::too_many_lines)]
     pub fn validate(&self, data: &Value) -> Result<(), ValidationError> {
         let processed_data = self.preprocess_binary_fields(data);
 
@@ -131,41 +142,39 @@ impl SchemaValidator {
                         if let Some(end) = error_msg[start + 1..].find('"') {
                             error_msg[start + 1..start + 1 + end].to_string()
                         } else {
-                            "".to_string()
+                            String::new()
                         }
                     } else {
-                        "".to_string()
+                        String::new()
                     };
 
-                    if !instance_path.is_empty() && instance_path.starts_with('/') && instance_path.len() > 1 {
+                    if instance_path.starts_with('/') && instance_path.len() > 1 {
                         let base_path = &instance_path[1..];
-                        if !field_name.is_empty() {
-                            format!("{}/{}", base_path, field_name)
-                        } else {
+                        if field_name.is_empty() {
                             base_path.to_string()
+                        } else {
+                            format!("{base_path}/{field_name}")
                         }
-                    } else if !field_name.is_empty() {
-                        field_name
-                    } else {
+                    } else if field_name.is_empty() {
                         "body".to_string()
+                    } else {
+                        field_name
                     }
                 } else if schema_path_str.contains("/additionalProperties") {
                     if let Some(start) = error_msg.find('(') {
                         if let Some(quote_start) = error_msg[start..].find('\'') {
                             let abs_start = start + quote_start + 1;
-                            if let Some(quote_end) = error_msg[abs_start..].find('\'') {
-                                let property_name = error_msg[abs_start..abs_start + quote_end].to_string();
-                                if !instance_path.is_empty()
-                                    && instance_path.starts_with('/')
-                                    && instance_path.len() > 1
-                                {
-                                    format!("{}/{}", &instance_path[1..], property_name)
-                                } else {
-                                    property_name
-                                }
-                            } else {
-                                instance_path[1..].to_string()
-                            }
+                            error_msg[abs_start..].find('\'').map_or_else(
+                                || instance_path[1..].to_string(),
+                                |quote_end| {
+                                    let property_name = error_msg[abs_start..abs_start + quote_end].to_string();
+                                    if instance_path.starts_with('/') && instance_path.len() > 1 {
+                                        format!("{}/{property_name}", &instance_path[1..])
+                                    } else {
+                                        property_name
+                                    }
+                                },
+                            )
                         } else {
                             instance_path[1..].to_string()
                         }
@@ -184,7 +193,7 @@ impl SchemaValidator {
 
                 let loc_parts: Vec<String> = if param_name.contains('/') {
                     let mut parts = vec!["body".to_string()];
-                    parts.extend(param_name.split('/').map(|s| s.to_string()));
+                    parts.extend(param_name.split('/').map(ToString::to_string));
                     parts
                 } else if param_name == "body" {
                     vec!["body".to_string()]
@@ -201,7 +210,7 @@ impl SchemaValidator {
                 let schema_prop_path = if param_name.contains('/') {
                     format!("/properties/{}", param_name.replace('/', "/properties/"))
                 } else {
-                    format!("/properties/{}", param_name)
+                    format!("/properties/{param_name}")
                 };
 
                 let mut error_condition = ErrorCondition::from_schema_error(schema_path_str, &error_msg);
@@ -210,13 +219,14 @@ impl SchemaValidator {
                     ErrorCondition::TypeMismatch { .. } => {
                         let expected_type = self
                             .schema
-                            .pointer(&format!("{}/type", schema_prop_path))
+                            .pointer(&format!("{schema_prop_path}/type"))
                             .and_then(|v| v.as_str())
                             .unwrap_or("unknown")
                             .to_string();
                         ErrorCondition::TypeMismatch { expected_type }
                     }
                     ErrorCondition::AdditionalProperties { .. } => {
+                        #[allow(clippy::redundant_clone)]
                         let unexpected_field = if param_name.contains('/') {
                             param_name.split('/').next_back().unwrap_or(&param_name).to_string()
                         } else {
@@ -268,12 +278,15 @@ impl SchemaValidator {
     }
 
     /// Validate and parse JSON bytes
+    ///
+    /// # Errors
+    /// Returns a validation error if the JSON is invalid or fails validation against the schema.
     pub fn validate_json(&self, json_bytes: &[u8]) -> Result<Value, ValidationError> {
         let value: Value = serde_json::from_slice(json_bytes).map_err(|e| ValidationError {
             errors: vec![ValidationErrorDetail {
                 error_type: "json_parse_error".to_string(),
                 loc: vec!["body".to_string()],
-                msg: format!("Invalid JSON: {}", e),
+                msg: format!("Invalid JSON: {e}"),
                 input: Value::Null,
                 ctx: None,
             }],
@@ -447,7 +460,7 @@ mod tests {
         });
 
         let result = validator.validate(&data);
-        eprintln!("Validation result: {:?}", result);
+        eprintln!("Validation result: {result:?}");
 
         assert!(result.is_err(), "Should have validation errors");
         let err = result.unwrap_err();

data/vendor/crates/spikard-core/tests/di_dependency_defaults.rs

@@ -20,7 +20,7 @@ impl Dependency for DummyDependency {
         Box::pin(async move { Ok(Arc::new(()) as Arc<dyn Any + Send + Sync>) })
     }
 
-    fn key(&self) -> &str {
+    fn key(&self) -> &'static str {
         "dummy"
     }
 

data/vendor/crates/spikard-core/tests/error_mapper.rs

@@ -466,7 +466,7 @@ fn test_error_context_includes_constraints() {
     let err = result.unwrap_err();
     assert!(err.errors[0].ctx.is_some());
     let ctx = err.errors[0].ctx.as_ref().unwrap();
-    assert_eq!(ctx.get("min_length").and_then(|v| v.as_u64()), Some(5));
+    assert_eq!(ctx.get("min_length").and_then(serde_json::Value::as_u64), Some(5));
 }
 
 #[test]
@@ -631,7 +631,7 @@ fn test_error_messages_are_user_friendly() {
     let msg = &err.errors[0].msg;
     assert!(msg.contains("18") || msg.contains("minimum"));
     assert!(!msg.contains("exclusiveMinimum"));
-    assert!(!msg.contains("$"));
+    assert!(!msg.contains('$'));
 }
 
 #[test]

data/vendor/crates/spikard-core/tests/parameters_edge_cases.rs

@@ -39,7 +39,7 @@ fn test_query_boolean_empty_string_coerces_to_false() {
     let validator = ParameterValidator::new(schema).expect("validator");
 
     let mut raw_query_params = HashMap::new();
-    raw_query_params.insert("flag".to_string(), vec!["".to_string()]);
+    raw_query_params.insert("flag".to_string(), vec![String::new()]);
 
     let extracted = validator.validate_and_extract(
         &json!({}),

data/vendor/crates/spikard-core/tests/parameters_full.rs

@@ -1,7 +1,7 @@
 //! Comprehensive parameter validation tests
 //!
 //! These tests cover header, cookie, and query parameter validation scenarios
-//! using the ParameterValidator from spikard-core.
+//! using the `ParameterValidator` from spikard-core.
 
 use serde_json::json;
 use spikard_core::parameters::ParameterValidator;