spikard 0.8.2 → 0.8.3

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

@@ -82,7 +82,8 @@ impl ProblemDetails {
     /// Standard type URI for bad request (400)
     pub const TYPE_BAD_REQUEST: &'static str = "https://spikard.dev/errors/bad-request";
 
-    /// Create a new ProblemDetails with required fields
+    /// Create a new `ProblemDetails` with required fields
+    #[must_use]
     pub fn new(type_uri: impl Into<String>, title: impl Into<String>, status: StatusCode) -> Self {
         Self {
             type_uri: type_uri.into(),
@@ -95,24 +96,29 @@ impl ProblemDetails {
     }
 
     /// Set the detail field
+    #[must_use]
     pub fn with_detail(mut self, detail: impl Into<String>) -> Self {
         self.detail = Some(detail.into());
         self
     }
 
     /// Set the instance field
+    #[must_use]
     pub fn with_instance(mut self, instance: impl Into<String>) -> Self {
         self.instance = Some(instance.into());
         self
     }
 
     /// Add an extension field
+    #[must_use]
     pub fn with_extension(mut self, key: impl Into<String>, value: Value) -> Self {
         self.extensions.insert(key.into(), value);
         self
     }
 
     /// Add all extensions from a JSON object
+    #[must_use]
+    #[allow(clippy::needless_pass_by_value)]
     pub fn with_extensions(mut self, extensions: Value) -> Self {
         if let Some(obj) = extensions.as_object() {
             for (key, value) in obj {
@@ -122,20 +128,21 @@ impl ProblemDetails {
         self
     }
 
-    /// Create a validation error Problem Details from ValidationError
+    /// Create a validation error Problem Details from `ValidationError`
     ///
     /// This converts the FastAPI-style validation errors to RFC 9457 format:
-    /// - `type`: "https://spikard.dev/errors/validation-error"
+    /// - `type`: <https://spikard.dev/errors/validation-error>
     /// - `title`: "Request Validation Failed"
     /// - `status`: 422
     /// - `detail`: Summary of error count
     /// - `errors`: Array of validation error details (as extension field)
+    #[must_use]
     pub fn from_validation_error(error: &ValidationError) -> Self {
         let error_count = error.errors.len();
         let detail = if error_count == 1 {
             "1 validation error in request".to_string()
         } else {
-            format!("{} validation errors in request", error_count)
+            format!("{error_count} validation errors in request")
         };
 
         let errors_json = serde_json::to_value(&error.errors).unwrap_or_else(|_| serde_json::Value::Array(vec![]));
@@ -201,16 +208,23 @@ impl ProblemDetails {
     }
 
     /// Get the HTTP status code
+    #[must_use]
     pub fn status_code(&self) -> StatusCode {
         StatusCode::from_u16(self.status).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
     }
 
     /// Serialize to JSON string
+    ///
+    /// # Errors
+    /// Returns an error if the serialization fails.
     pub fn to_json(&self) -> Result<String, serde_json::Error> {
         serde_json::to_string(self)
     }
 
     /// Serialize to pretty JSON string
+    ///
+    /// # Errors
+    /// Returns an error if the serialization fails.
     pub fn to_json_pretty(&self) -> Result<String, serde_json::Error> {
         serde_json::to_string_pretty(self)
     }

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

@@ -17,19 +17,19 @@ use bytes::Bytes;
 ///
 /// This is the language-agnostic representation passed to handlers.
 ///
-/// Uses Arc for HashMaps to enable cheap cloning without duplicating data.
-/// When RequestData is cloned, only the Arc pointers are cloned, not the underlying data.
+/// Uses `Arc` for `HashMap`s to enable cheap cloning without duplicating data.
+/// When `RequestData` is cloned, only the `Arc` pointers are cloned, not the underlying data.
 ///
-/// Performance optimization: raw_body stores the unparsed request body bytes.
-/// Language bindings should use raw_body when possible to avoid double-parsing.
-/// The body field is lazily parsed only when needed for validation.
+/// Performance optimization: `raw_body` stores the unparsed request body bytes.
+/// Language bindings should use `raw_body` when possible to avoid double-parsing.
+/// The `body` field is lazily parsed only when needed for validation.
 #[derive(Debug, Clone)]
 pub struct RequestData {
     /// Path parameters extracted from the URL path
     pub path_params: Arc<HashMap<String, String>>,
     /// Query parameters parsed as JSON
     pub query_params: Value,
-    /// Validated parameters produced by ParameterValidator (query/path/header/cookie combined).
+    /// Validated parameters produced by `ParameterValidator` (query/path/header/cookie combined).
     pub validated_params: Option<Value>,
     /// Raw query parameters as key-value pairs
     pub raw_query_params: Arc<HashMap<String, Vec<String>>>,
@@ -66,7 +66,7 @@ impl Serialize for RequestData {
         state.serialize_field("raw_query_params", &*self.raw_query_params)?;
         state.serialize_field("body", &self.body)?;
         #[cfg(feature = "di")]
-        state.serialize_field("raw_body", &self.raw_body.as_ref().map(|b| b.as_ref()))?;
+        state.serialize_field("raw_body", &self.raw_body.as_ref().map(AsRef::as_ref))?;
         #[cfg(not(feature = "di"))]
         state.serialize_field("raw_body", &self.raw_body)?;
         state.serialize_field("headers", &*self.headers)?;
@@ -78,6 +78,7 @@ impl Serialize for RequestData {
 }
 
 impl<'de> Deserialize<'de> for RequestData {
+    #[allow(clippy::too_many_lines)]
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -933,7 +934,7 @@ mod tests {
             "float": 3.2,
             "negative": -100,
             "zero": 0,
-            "large": 9223372036854775807i64
+            "large": 9_223_372_036_854_775_807i64
         });
 
         let data = create_request_data(

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()
     }
 }
 

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()

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);
 
@@ -204,7 +209,8 @@ pub fn auto_generate_parameter_schema(route_path: &str) -> Option<Value> {
 /// 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());

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,

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,
             }],