RubyGems - spikard - Versions diffs - 0.8.2 → 0.8.3 - Mend

spikard 0.8.2 → 0.8.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

data/vendor/crates/spikard-bindings-shared/src/lifecycle_base.rs CHANGED Viewed

@@ -29,6 +29,10 @@ pub enum HookResult {
 /// Trait for implementing lifecycle hooks in language bindings
 pub trait LifecycleHook: Send + Sync {
     /// Execute the lifecycle hook
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if hook execution fails.
     fn execute(&self, context: serde_json::Value) -> Result<HookResult, String>;
     /// Get the hook type
@@ -43,6 +47,7 @@ pub struct LifecycleConfig {
 impl LifecycleConfig {
     /// Create a new lifecycle configuration
+    #[must_use]
     pub fn new() -> Self {
         Self {
             hooks: std::collections::HashMap::new(),
@@ -55,6 +60,7 @@ impl LifecycleConfig {
     }
     /// Get hooks for a specific type
+    #[must_use]
     pub fn get_hooks(&self, hook_type: LifecycleHookType) -> Vec<Arc<dyn LifecycleHook>> {
         self.hooks.get(&hook_type).cloned().unwrap_or_default()
     }

data/vendor/crates/spikard-bindings-shared/src/lifecycle_executor.rs CHANGED Viewed

@@ -10,7 +10,7 @@
 //! `LanguageLifecycleHook` to provide language-specific hook invocation, while
 //! `LifecycleExecutor` handles the common logic:
 //!
-//! - Hook result type handling (Continue vs ShortCircuit)
+//! - Hook result type handling (Continue vs `ShortCircuit`)
 //! - Response/Request building from hook results
 //! - Error handling and conversion
 //!
@@ -73,7 +73,8 @@ pub struct RequestModifications {
 impl HookResultData {
     /// Create a Continue result (pass through)
-    pub fn continue_execution() -> Self {
+    #[must_use]
+    pub const fn continue_execution() -> Self {
         Self {
             continue_execution: true,
             status_code: None,
@@ -84,7 +85,8 @@ impl HookResultData {
     }
     /// Create a short-circuit response result
-    pub fn short_circuit(status_code: u16, body: Vec<u8>, headers: Option<HashMap<String, String>>) -> Self {
+    #[must_use]
+    pub const fn short_circuit(status_code: u16, body: Vec<u8>, headers: Option<HashMap<String, String>>) -> Self {
         Self {
             continue_execution: false,
             status_code: Some(status_code),
@@ -95,7 +97,8 @@ impl HookResultData {
     }
     /// Create a request modification result
-    pub fn modify_request(modifications: RequestModifications) -> Self {
+    #[must_use]
+    pub const fn modify_request(modifications: RequestModifications) -> Self {
         Self {
             continue_execution: true,
             status_code: None,
@@ -117,6 +120,10 @@ pub trait LanguageLifecycleHook: Send + Sync {
     /// Prepare hook data from the incoming request/response
     ///
     /// This should convert axum HTTP types to language-specific representations.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if hook data preparation fails.
     fn prepare_hook_data(&self, req: &Request<Body>) -> Result<Self::HookData, String>;
     /// Invoke the language hook and return normalized result data
@@ -139,13 +146,17 @@ pub struct LifecycleExecutor<L: LanguageLifecycleHook> {
 impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
     /// Create a new executor for the given hook
-    pub fn new(hook: Arc<L>) -> Self {
+    pub const fn new(hook: Arc<L>) -> Self {
         Self { hook }
     }
     /// Execute a request hook, handling Continue/ShortCircuit semantics
     ///
     /// Returns either the modified request or a short-circuit response.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if hook execution or modification fails.
     pub async fn execute_request_hook(
         &self,
         req: Request<Body>,
@@ -154,12 +165,12 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
         let result = self.hook.invoke_hook(hook_data).await?;
         if !result.continue_execution {
-            let response = self.build_response_from_hook_result(&result)?;
+            let response = Self::build_response_from_hook_result(&result)?;
             return Ok(Err(response));
         }
         if let Some(modifications) = result.request_modifications {
-            let modified_req = self.apply_request_modifications(req, modifications)?;
+            let modified_req = Self::apply_request_modifications(req, modifications)?;
             Ok(Ok(modified_req))
         } else {
             Ok(Ok(req))
@@ -170,6 +181,11 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
     ///
     /// Response hooks can only continue or modify the response,
     /// never short-circuit.
+    /// Execute the lifecycle hook on an outgoing response
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if hook execution or response building fails.
     pub async fn execute_response_hook(&self, resp: Response<Body>) -> Result<Response<Body>, String> {
         let (parts, body) = resp.into_parts();
         let body_bytes = extract_body(body).await?;
@@ -178,7 +194,7 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
             .method("GET")
             .uri("/")
             .body(Body::empty())
-            .map_err(|e| format!("Failed to build dummy request: {}", e))?;
+            .map_err(|e| format!("Failed to build dummy request: {e}"))?;
         let hook_data = self.hook.prepare_hook_data(&dummy_req)?;
         let result = self.hook.invoke_hook(hook_data).await?;
@@ -198,7 +214,7 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
                 }
             }
-            for (name, value) in parts.headers.iter() {
+            for (name, value) in &parts.headers {
                 let key_str = name.as_str().to_lowercase();
                 if !header_mod_keys.contains(&key_str) {
                     builder = builder.header(name, value);
@@ -208,7 +224,7 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
             let body = modifications.body.unwrap_or(body_bytes);
             return builder
                 .body(Body::from(body))
-                .map_err(|e| format!("Failed to build modified response: {}", e));
+                .map_err(|e| format!("Failed to build modified response: {e}"));
         }
         let mut builder = Response::builder().status(parts.status);
@@ -219,14 +235,14 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
         }
         builder
             .body(Body::from(body_bytes))
-            .map_err(|e| format!("Failed to rebuild response: {}", e))
+            .map_err(|e| format!("Failed to rebuild response: {e}"))
     }
     /// Build an axum Response from hook result data
-    fn build_response_from_hook_result(&self, result: &HookResultData) -> Result<Response<Body>, String> {
+    fn build_response_from_hook_result(result: &HookResultData) -> Result<Response<Body>, String> {
         let status_code = result.status_code.unwrap_or(200);
         let status =
-            StatusCode::from_u16(status_code).map_err(|e| format!("Invalid status code {}: {}", status_code, e))?;
+            StatusCode::from_u16(status_code).map_err(|e| format!("Invalid status code {status_code}: {e}"))?;
         let mut builder = Response::builder().status(status);
@@ -236,11 +252,7 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
             }
         }
-        if !builder
-            .headers_ref()
-            .map(|h| h.contains_key("content-type"))
-            .unwrap_or(false)
-        {
+        if !builder.headers_ref().is_some_and(|h| h.contains_key("content-type")) {
             builder = builder.header("content-type", "application/json");
         }
@@ -248,43 +260,33 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
         builder
             .body(Body::from(body))
-            .map_err(|e| format!("Failed to build response: {}", e))
+            .map_err(|e| format!("Failed to build response: {e}"))
     }
     /// Apply request modifications to a request
-    fn apply_request_modifications(
-        &self,
-        req: Request<Body>,
-        mods: RequestModifications,
-    ) -> Result<Request<Body>, String> {
+    fn apply_request_modifications(req: Request<Body>, mods: RequestModifications) -> Result<Request<Body>, String> {
         let (mut parts, body) = req.into_parts();
         if let Some(method) = &mods.method {
-            parts.method = method
-                .parse()
-                .map_err(|e| format!("Invalid method '{}': {}", method, e))?;
+            parts.method = method.parse().map_err(|e| format!("Invalid method '{method}': {e}"))?;
         }
         if let Some(path) = &mods.path {
-            parts.uri = path.parse().map_err(|e| format!("Invalid path '{}': {}", path, e))?;
+            parts.uri = path.parse().map_err(|e| format!("Invalid path '{path}': {e}"))?;
         }
         if let Some(new_headers) = &mods.headers {
             for (key, value) in new_headers {
                 let header_name: http::header::HeaderName =
-                    key.parse().map_err(|_| format!("Invalid header name: {}", key))?;
+                    key.parse().map_err(|_| format!("Invalid header name: {key}"))?;
                 let header_value: http::header::HeaderValue = value
                     .parse()
-                    .map_err(|_| format!("Invalid header value for {}: {}", key, value))?;
+                    .map_err(|_| format!("Invalid header value for {key}: {value}"))?;
                 parts.headers.insert(header_name, header_value);
             }
         }
-        let body = if let Some(new_body) = mods.body {
-            Body::from(new_body)
-        } else {
-            body
-        };
+        let body = mods.body.map_or(body, Body::from);
         Ok(Request::from_parts(parts, body))
     }
@@ -293,13 +295,17 @@ impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
 /// Extract body bytes from an axum Body
 ///
 /// This is a helper used by lifecycle executors to read response bodies.
+///
+/// # Errors
+///
+/// Returns an error if body collection fails.
 pub async fn extract_body(body: Body) -> Result<Vec<u8>, String> {
     use http_body_util::BodyExt;
     let bytes = body
         .collect()
         .await
-        .map_err(|e| format!("Failed to read body: {}", e))?
+        .map_err(|e| format!("Failed to read body: {e}"))?
         .to_bytes();
     Ok(bytes.to_vec())
 }

data/vendor/crates/spikard-bindings-shared/src/response_builder.rs CHANGED Viewed

@@ -12,6 +12,7 @@ pub struct ResponseBuilder {
 impl ResponseBuilder {
     /// Create a new response builder with default status 200 OK
+    #[must_use]
     pub fn new() -> Self {
         Self {
             status: StatusCode::OK,
@@ -21,18 +22,21 @@ impl ResponseBuilder {
     }
     /// Set the HTTP status code
-    pub fn status(mut self, status: StatusCode) -> Self {
+    #[must_use]
+    pub const fn status(mut self, status: StatusCode) -> Self {
         self.status = status;
         self
     }
     /// Set the response body
+    #[must_use]
     pub fn body(mut self, body: serde_json::Value) -> Self {
         self.body = body;
         self
     }
     /// Add a response header
+    #[must_use]
     pub fn header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
         if let Ok(name) = key.into().parse::<header::HeaderName>()
             && let Ok(val) = value.into().parse::<header::HeaderValue>()
@@ -43,6 +47,7 @@ impl ResponseBuilder {
     }
     /// Build the response as (status, headers, body)
+    #[must_use]
     pub fn build(self) -> (StatusCode, HeaderMap, String) {
         let body = serde_json::to_string(&self.body).unwrap_or_else(|_| "{}".to_string());
         (self.status, self.headers, body)

data/vendor/crates/spikard-bindings-shared/src/test_client_base.rs CHANGED Viewed

@@ -23,13 +23,15 @@ impl TestClientConfig {
     }
     /// Set the timeout in milliseconds
-    pub fn with_timeout(mut self, timeout_ms: u64) -> Self {
+    #[must_use]
+    pub const fn with_timeout(mut self, timeout_ms: u64) -> Self {
         self.timeout_ms = timeout_ms;
         self
     }
     /// Set whether to follow redirects
-    pub fn with_follow_redirects(mut self, follow_redirects: bool) -> Self {
+    #[must_use]
+    pub const fn with_follow_redirects(mut self, follow_redirects: bool) -> Self {
         self.follow_redirects = follow_redirects;
         self
     }
@@ -60,7 +62,13 @@ pub struct TestResponseMetadata {
 impl TestResponseMetadata {
     /// Create a new test response metadata
-    pub fn new(status_code: u16, headers: HashMap<String, String>, body_size: usize, response_time_ms: u64) -> Self {
+    #[must_use]
+    pub const fn new(
+        status_code: u16,
+        headers: HashMap<String, String>,
+        body_size: usize,
+        response_time_ms: u64,
+    ) -> Self {
         Self {
             status_code,
             headers,
@@ -70,6 +78,7 @@ impl TestResponseMetadata {
     }
     /// Get a header value by name (case-insensitive)
+    #[must_use]
     pub fn get_header(&self, name: &str) -> Option<&String> {
         let lower_name = name.to_lowercase();
         self.headers
@@ -79,17 +88,20 @@ impl TestResponseMetadata {
     }
     /// Check if response was successful (2xx status code)
-    pub fn is_success(&self) -> bool {
+    #[must_use]
+    pub const fn is_success(&self) -> bool {
         self.status_code >= 200 && self.status_code < 300
     }
     /// Check if response was a client error (4xx status code)
-    pub fn is_client_error(&self) -> bool {
+    #[must_use]
+    pub const fn is_client_error(&self) -> bool {
         self.status_code >= 400 && self.status_code < 500
     }
     /// Check if response was a server error (5xx status code)
-    pub fn is_server_error(&self) -> bool {
+    #[must_use]
+    pub const fn is_server_error(&self) -> bool {
         self.status_code >= 500 && self.status_code < 600
     }
 }

data/vendor/crates/spikard-bindings-shared/src/validation_helpers.rs CHANGED Viewed

@@ -7,29 +7,37 @@ pub struct HeaderValidator;
 impl HeaderValidator {
     /// Validate that required headers are present
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required headers are missing.
     pub fn validate_required(headers: &[(String, String)], required: &[&str]) -> Result<(), String> {
         let header_names: std::collections::HashSet<_> = headers.iter().map(|(k, _)| k.to_lowercase()).collect();
         for req in required {
             if !header_names.contains(&req.to_lowercase()) {
-                return Err(format!("Missing required header: {}", req));
+                return Err(format!("Missing required header: {req}"));
             }
         }
         Ok(())
     }
     /// Validate header format
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the header format is invalid.
     pub fn validate_format(key: &str, value: &str, format: HeaderFormat) -> Result<(), String> {
         match format {
             HeaderFormat::Bearer => {
                 if !value.starts_with("Bearer ") {
-                    return Err(format!("{}: must start with 'Bearer '", key));
+                    return Err(format!("{key}: must start with 'Bearer '"));
                 }
                 Ok(())
             }
             HeaderFormat::Json => {
                 if !value.starts_with("application/json") {
-                    return Err(format!("{}: must be 'application/json'", key));
+                    return Err(format!("{key}: must be 'application/json'"));
                 }
                 Ok(())
             }
@@ -38,6 +46,7 @@ impl HeaderValidator {
 }
 /// Header validation formats
+#[derive(Copy, Clone)]
 pub enum HeaderFormat {
     /// Bearer token format
     Bearer,
@@ -50,6 +59,10 @@ pub struct BodyValidator;
 impl BodyValidator {
     /// Validate that required fields are present in a JSON object
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required fields are missing.
     pub fn validate_required_fields(body: &Value, required: &[&str]) -> Result<(), String> {
         let obj = body
             .as_object()
@@ -57,44 +70,48 @@ impl BodyValidator {
         for field in required {
             if !obj.contains_key(*field) {
-                return Err(format!("Missing required field: {}", field));
+                return Err(format!("Missing required field: {field}"));
             }
         }
         Ok(())
     }
     /// Validate field type
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the field type doesn't match.
     pub fn validate_field_type(body: &Value, field: &str, expected_type: FieldType) -> Result<(), String> {
         let obj = body
             .as_object()
             .ok_or_else(|| "Body must be a JSON object".to_string())?;
-        let value = obj.get(field).ok_or_else(|| format!("Field not found: {}", field))?;
+        let value = obj.get(field).ok_or_else(|| format!("Field not found: {field}"))?;
         match expected_type {
             FieldType::String => {
                 if !value.is_string() {
-                    return Err(format!("{}: expected string", field));
+                    return Err(format!("{field}: expected string"));
                 }
             }
             FieldType::Number => {
                 if !value.is_number() {
-                    return Err(format!("{}: expected number", field));
+                    return Err(format!("{field}: expected number"));
                 }
             }
             FieldType::Boolean => {
                 if !value.is_boolean() {
-                    return Err(format!("{}: expected boolean", field));
+                    return Err(format!("{field}: expected boolean"));
                 }
             }
             FieldType::Object => {
                 if !value.is_object() {
-                    return Err(format!("{}: expected object", field));
+                    return Err(format!("{field}: expected object"));
                 }
             }
             FieldType::Array => {
                 if !value.is_array() {
-                    return Err(format!("{}: expected array", field));
+                    return Err(format!("{field}: expected array"));
                 }
             }
         }
@@ -103,6 +120,7 @@ impl BodyValidator {
 }
 /// Field types for validation
+#[derive(Copy, Clone)]
 pub enum FieldType {
     String,
     Number,

data/vendor/crates/spikard-core/Cargo.toml CHANGED Viewed

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-core"
-version = "0.8.2"
+version = "0.8.3"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"
@@ -12,6 +12,14 @@ categories = ["web-programming::http-server", "web-programming", "development-to
 documentation = "https://docs.rs/spikard-core"
 readme = "README.md"
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(tarpaulin_include)'] }
+[lints.clippy]
+all = { level = "deny", priority = 0 }
+pedantic = { level = "deny", priority = 0 }
+nursery = { level = "deny", priority = 0 }
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

data/vendor/crates/spikard-core/src/bindings/response.rs CHANGED Viewed

@@ -15,6 +15,8 @@ pub struct RawResponse {
 impl RawResponse {
     /// Construct a new response.
+    #[must_use]
+    #[allow(clippy::missing_const_for_fn)]
     pub fn new(status: u16, headers: HashMap<String, String>, body: Vec<u8>) -> Self {
         Self { status, headers, body }
     }
@@ -35,19 +37,13 @@ impl RawResponse {
             return;
         }
-        let accept_encoding = header_value(request_headers, "Accept-Encoding").map(|value| value.to_ascii_lowercase());
-        let accepts_brotli = accept_encoding
-            .as_ref()
-            .map(|value| value.contains("br"))
-            .unwrap_or(false);
+        let accept_encoding = header_value(request_headers, "Accept-Encoding").map(str::to_ascii_lowercase);
+        let accepts_brotli = accept_encoding.as_ref().is_some_and(|value| value.contains("br"));
         if compression.brotli && accepts_brotli && self.try_compress_brotli(compression) {
             return;
         }
-        let accepts_gzip = accept_encoding
-            .as_ref()
-            .map(|value| value.contains("gzip"))
-            .unwrap_or(false);
+        let accepts_gzip = accept_encoding.as_ref().is_some_and(|value| value.contains("gzip"));
         if compression.gzip && accepts_gzip {
             self.try_compress_gzip(compression);
         }
@@ -110,6 +106,7 @@ pub struct StaticAsset {
 impl StaticAsset {
     /// Build a response snapshot if the incoming request targets this asset.
+    #[must_use]
     pub fn serve(&self, method: &str, normalized_path: &str) -> Option<RawResponse> {
         if !method.eq_ignore_ascii_case("GET") && !method.eq_ignore_ascii_case("HEAD") {
             return None;

data/vendor/crates/spikard-core/src/debug.rs CHANGED Viewed

@@ -1,8 +1,8 @@
 //! Debug logging utilities for spikard-http
 //!
 //! This module provides debug logging that can be enabled via:
-//! - Building in debug mode (cfg(debug_assertions))
-//! - Setting SPIKARD_DEBUG=1 environment variable
+//! - Building in debug mode (`cfg(debug_assertions)`)
+//! - Setting `SPIKARD_DEBUG=1` environment variable
 use std::sync::atomic::{AtomicBool, Ordering};

data/vendor/crates/spikard-core/src/di/container.rs CHANGED Viewed

@@ -365,7 +365,7 @@ impl std::fmt::Debug for DependencyContainer {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("DependencyContainer")
             .field("dependencies", &self.dependencies.keys())
-            .finish()
+            .finish_non_exhaustive()
     }
 }

data/vendor/crates/spikard-core/src/di/error.rs CHANGED Viewed

@@ -33,7 +33,7 @@ pub enum DependencyError {
     /// ```
     #[error("Circular dependency detected: {cycle:?}")]
     CircularDependency {
-        /// The cycle of dependencies (e.g., ["A", "B", "C", "A"])
+        /// The cycle of dependencies (e.g., `["A", "B", "C", "A"]`)
         cycle: Vec<String>,
     },

data/vendor/crates/spikard-core/src/di/factory.rs CHANGED Viewed

@@ -134,7 +134,7 @@ impl std::fmt::Debug for FactoryDependency {
             .field("dependencies", &self.dependencies)
             .field("cacheable", &self.cacheable)
             .field("singleton", &self.singleton)
-            .finish()
+            .finish_non_exhaustive()
     }
 }
@@ -209,6 +209,7 @@ impl FactoryDependencyBuilder {
     ///     })
     ///     .build();
     /// ```
+    #[must_use]
     pub fn factory<F>(mut self, factory: F) -> Self
     where
         F: Fn(
@@ -245,6 +246,7 @@ impl FactoryDependencyBuilder {
     ///     })
     ///     .build();
     /// ```
+    #[must_use]
     pub fn depends_on(mut self, dependencies: Vec<String>) -> Self {
         self.dependencies = dependencies;
         self
@@ -272,7 +274,8 @@ impl FactoryDependencyBuilder {
     ///     .cacheable(true)  // Same ID for all uses in one request
     ///     .build();
     /// ```
-    pub fn cacheable(mut self, cacheable: bool) -> Self {
+    #[must_use]
+    pub const fn cacheable(mut self, cacheable: bool) -> Self {
         self.cacheable = cacheable;
         self
     }
@@ -300,7 +303,8 @@ impl FactoryDependencyBuilder {
     ///     .singleton(true)  // Share across all requests
     ///     .build();
     /// ```
-    pub fn singleton(mut self, singleton: bool) -> Self {
+    #[must_use]
+    pub const fn singleton(mut self, singleton: bool) -> Self {
         self.singleton = singleton;
         self
     }

data/vendor/crates/spikard-core/src/di/graph.rs CHANGED Viewed

@@ -133,6 +133,7 @@ impl DependencyGraph {
     /// // Adding c -> [] would not
     /// assert!(!graph.has_cycle_with("c", &[]));
     /// ```
+    #[must_use]
     pub fn has_cycle_with(&self, new_key: &str, new_deps: &[String]) -> bool {
         let mut temp_graph = self.graph.clone();
         temp_graph.insert(new_key.to_string(), new_deps.to_vec());