spikard 0.3.5 → 0.5.0

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

@@ -1,40 +1,40 @@
-[package]
-name = "spikard-core"
-version = "0.3.5"
-edition = "2024"
-authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
-license = "MIT"
-repository = "https://github.com/Goldziher/spikard"
-homepage = "https://github.com/Goldziher/spikard"
-description = "Shared transport-agnostic primitives for Spikard runtimes"
-keywords = ["http", "web", "framework", "validation", "middleware"]
-categories = ["web-programming::http-server", "web-programming", "development-tools"]
-documentation = "https://docs.rs/spikard-core"
-readme = "README.md"
-
-[dependencies]
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-tracing = "0.1"
-anyhow = "1.0"
-jsonschema = { version = "0.37", default-features = false }
-regex = "1"
-flate2 = "1.1"
-brotli = "8.0"
-http = "1.4"
-base64 = "0.22"
-serde_qs = "0.15"
-url = "2.5"
-jiff = "0.2"
-uuid = "1.18"
-indexmap = "2.12"
-tokio = { version = "1", features = ["full"], optional = true }
-bytes = { version = "1.11", optional = true }
-thiserror = { version = "2.0", optional = true }
-
-[features]
-default = []
-di = ["dep:tokio", "dep:bytes", "dep:thiserror"]
-
-[dev-dependencies]
-tokio-test = "0.4"
+[package]
+name = "spikard-core"
+version = "0.5.0"
+edition = "2024"
+authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
+license = "MIT"
+repository = "https://github.com/Goldziher/spikard"
+homepage = "https://github.com/Goldziher/spikard"
+description = "Shared transport-agnostic primitives for Spikard runtimes"
+keywords = ["http", "web", "framework", "validation", "middleware"]
+categories = ["web-programming::http-server", "web-programming", "development-tools"]
+documentation = "https://docs.rs/spikard-core"
+readme = "README.md"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tracing = "0.1"
+anyhow = "1.0"
+jsonschema = { version = "0.37", default-features = false }
+regex = "1"
+flate2 = { version = "=1.1.5", default-features = false, features = ["rust_backend"] }
+brotli = "8.0"
+http = "1.4"
+base64 = "0.22"
+serde_qs = "0.15"
+url = "2.5"
+jiff = "0.2"
+uuid = "1.19"
+indexmap = "2.12"
+tokio = { version = "1", optional = true, default-features = false, features = ["rt", "macros", "sync", "time"] }
+bytes = { version = "1.11", optional = true }
+thiserror = { version = "2.0", optional = true }
+
+[features]
+default = []
+di = ["dep:tokio", "dep:bytes", "dep:thiserror"]
+
+[dev-dependencies]
+tokio-test = "0.4"

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

@@ -1,3 +1,3 @@
-pub mod response;
-
-pub use response::{RawResponse, StaticAsset};
+pub mod response;
+
+pub use response::{RawResponse, StaticAsset};

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

@@ -1,133 +1,133 @@
-use crate::CompressionConfig;
-use brotli::CompressorWriter;
-use flate2::Compression;
-use flate2::write::GzEncoder;
-use std::collections::HashMap;
-use std::io::Write;
-
-/// Minimal response container shared by bindings.
-#[derive(Clone, Debug)]
-pub struct RawResponse {
-    pub status: u16,
-    pub headers: HashMap<String, String>,
-    pub body: Vec<u8>,
-}
-
-impl RawResponse {
-    /// Construct a new response.
-    pub fn new(status: u16, headers: HashMap<String, String>, body: Vec<u8>) -> Self {
-        Self { status, headers, body }
-    }
-
-    /// Apply compression filters if the response qualifies.
-    pub fn apply_compression(&mut self, request_headers: &HashMap<String, String>, compression: &CompressionConfig) {
-        if self.body.is_empty() || self.status == 206 {
-            return;
-        }
-        if self
-            .headers
-            .keys()
-            .any(|key| key.eq_ignore_ascii_case("content-encoding"))
-        {
-            return;
-        }
-        if self.body.len() < compression.min_size {
-            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);
-        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);
-        if compression.gzip && accepts_gzip {
-            self.try_compress_gzip(compression);
-        }
-    }
-
-    fn try_compress_brotli(&mut self, compression: &CompressionConfig) -> bool {
-        let quality = compression.quality.min(11);
-        let mut writer = CompressorWriter::new(Vec::new(), 4096, quality, 22);
-        if writer.write_all(&self.body).is_err() || writer.flush().is_err() {
-            return false;
-        }
-        let compressed = writer.into_inner();
-        if compressed.is_empty() {
-            return false;
-        }
-        self.finalize_encoded_body("br", compressed);
-        true
-    }
-
-    fn try_compress_gzip(&mut self, compression: &CompressionConfig) -> bool {
-        let mut encoder = GzEncoder::new(Vec::new(), Compression::new(compression.quality));
-        if encoder.write_all(&self.body).is_err() {
-            return false;
-        }
-        let compressed = encoder.finish().unwrap_or_else(|_| Vec::new());
-        if compressed.is_empty() {
-            return false;
-        }
-        self.finalize_encoded_body("gzip", compressed);
-        true
-    }
-
-    fn finalize_encoded_body(&mut self, encoding: &str, compressed: Vec<u8>) {
-        self.body = compressed;
-        self.headers
-            .insert("content-encoding".to_string(), encoding.to_string());
-        self.headers.insert("vary".to_string(), "Accept-Encoding".to_string());
-        self.headers
-            .insert("content-length".to_string(), self.body.len().to_string());
-    }
-}
-
-fn header_value<'a>(headers: &'a HashMap<String, String>, name: &str) -> Option<&'a str> {
-    headers.iter().find_map(|(key, value)| {
-        if key.eq_ignore_ascii_case(name) {
-            Some(value.as_str())
-        } else {
-            None
-        }
-    })
-}
-
-/// Pre-rendered static asset produced by the CLI bundler.
-#[derive(Clone, Debug)]
-pub struct StaticAsset {
-    pub route: String,
-    pub headers: HashMap<String, String>,
-    pub body: Vec<u8>,
-}
-
-impl StaticAsset {
-    /// Build a response snapshot if the incoming request targets this asset.
-    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;
-        }
-        if self.route != normalized_path {
-            return None;
-        }
-
-        let mut headers = self.headers.clone();
-        headers
-            .entry("content-length".to_string())
-            .or_insert_with(|| self.body.len().to_string());
-        let body = if method.eq_ignore_ascii_case("HEAD") {
-            Vec::new()
-        } else {
-            self.body.clone()
-        };
-
-        Some(RawResponse::new(200, headers, body))
-    }
-}
+use crate::CompressionConfig;
+use brotli::CompressorWriter;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+use std::collections::HashMap;
+use std::io::Write;
+
+/// Minimal response container shared by bindings.
+#[derive(Clone, Debug)]
+pub struct RawResponse {
+    pub status: u16,
+    pub headers: HashMap<String, String>,
+    pub body: Vec<u8>,
+}
+
+impl RawResponse {
+    /// Construct a new response.
+    pub fn new(status: u16, headers: HashMap<String, String>, body: Vec<u8>) -> Self {
+        Self { status, headers, body }
+    }
+
+    /// Apply compression filters if the response qualifies.
+    pub fn apply_compression(&mut self, request_headers: &HashMap<String, String>, compression: &CompressionConfig) {
+        if self.body.is_empty() || self.status == 206 {
+            return;
+        }
+        if self
+            .headers
+            .keys()
+            .any(|key| key.eq_ignore_ascii_case("content-encoding"))
+        {
+            return;
+        }
+        if self.body.len() < compression.min_size {
+            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);
+        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);
+        if compression.gzip && accepts_gzip {
+            self.try_compress_gzip(compression);
+        }
+    }
+
+    fn try_compress_brotli(&mut self, compression: &CompressionConfig) -> bool {
+        let quality = compression.quality.min(11);
+        let mut writer = CompressorWriter::new(Vec::new(), 4096, quality, 22);
+        if writer.write_all(&self.body).is_err() || writer.flush().is_err() {
+            return false;
+        }
+        let compressed = writer.into_inner();
+        if compressed.is_empty() {
+            return false;
+        }
+        self.finalize_encoded_body("br", compressed);
+        true
+    }
+
+    fn try_compress_gzip(&mut self, compression: &CompressionConfig) -> bool {
+        let mut encoder = GzEncoder::new(Vec::new(), Compression::new(compression.quality));
+        if encoder.write_all(&self.body).is_err() {
+            return false;
+        }
+        let compressed = encoder.finish().unwrap_or_else(|_| Vec::new());
+        if compressed.is_empty() {
+            return false;
+        }
+        self.finalize_encoded_body("gzip", compressed);
+        true
+    }
+
+    fn finalize_encoded_body(&mut self, encoding: &str, compressed: Vec<u8>) {
+        self.body = compressed;
+        self.headers
+            .insert("content-encoding".to_string(), encoding.to_string());
+        self.headers.insert("vary".to_string(), "Accept-Encoding".to_string());
+        self.headers
+            .insert("content-length".to_string(), self.body.len().to_string());
+    }
+}
+
+fn header_value<'a>(headers: &'a HashMap<String, String>, name: &str) -> Option<&'a str> {
+    headers.iter().find_map(|(key, value)| {
+        if key.eq_ignore_ascii_case(name) {
+            Some(value.as_str())
+        } else {
+            None
+        }
+    })
+}
+
+/// Pre-rendered static asset produced by the CLI bundler.
+#[derive(Clone, Debug)]
+pub struct StaticAsset {
+    pub route: String,
+    pub headers: HashMap<String, String>,
+    pub body: Vec<u8>,
+}
+
+impl StaticAsset {
+    /// Build a response snapshot if the incoming request targets this asset.
+    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;
+        }
+        if self.route != normalized_path {
+            return None;
+        }
+
+        let mut headers = self.headers.clone();
+        headers
+            .entry("content-length".to_string())
+            .or_insert_with(|| self.body.len().to_string());
+        let body = if method.eq_ignore_ascii_case("HEAD") {
+            Vec::new()
+        } else {
+            self.body.clone()
+        };
+
+        Some(RawResponse::new(200, headers, body))
+    }
+}

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

@@ -1,63 +1,127 @@
-//! 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
-
-use std::sync::atomic::{AtomicBool, Ordering};
-
-static DEBUG_ENABLED: AtomicBool = AtomicBool::new(false);
-
-/// Initialize debug logging based on environment and build mode
-pub fn init() {
-    let enabled = cfg!(debug_assertions) || std::env::var("SPIKARD_DEBUG").is_ok() || std::env::var("DEBUG").is_ok();
-
-    eprintln!(
-        "[spikard-http::debug] init() called, cfg!(debug_assertions)={}, DEBUG={}, enabled={}",
-        cfg!(debug_assertions),
-        std::env::var("DEBUG").is_ok(),
-        enabled
-    );
-
-    DEBUG_ENABLED.store(enabled, Ordering::Relaxed);
-
-    if enabled {
-        eprintln!("[spikard-http] Debug logging enabled");
-    }
-}
-
-/// Check if debug logging is enabled
-#[inline]
-pub fn is_enabled() -> bool {
-    DEBUG_ENABLED.load(Ordering::Relaxed)
-}
-
-/// Log a debug message if debugging is enabled
-#[macro_export]
-macro_rules! debug_log {
-    ($($arg:tt)*) => {
-        if $crate::debug::is_enabled() {
-            eprintln!("[spikard-http] {}", format!($($arg)*));
-        }
-    };
-}
-
-/// Log a debug message with a specific module/component name
-#[macro_export]
-macro_rules! debug_log_module {
-    ($module:expr, $($arg:tt)*) => {
-        if $crate::debug::is_enabled() {
-            eprintln!("[spikard-http::{}] {}", $module, format!($($arg)*));
-        }
-    };
-}
-
-/// Log a debug value with pretty-printing
-#[macro_export]
-macro_rules! debug_log_value {
-    ($name:expr, $value:expr) => {
-        if $crate::debug::is_enabled() {
-            eprintln!("[spikard-http] {} = {:?}", $name, $value);
-        }
-    };
-}
+//! 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
+
+use std::sync::atomic::{AtomicBool, Ordering};
+
+static DEBUG_ENABLED: AtomicBool = AtomicBool::new(false);
+
+/// Initialize debug logging based on environment and build mode
+pub fn init() {
+    let enabled = cfg!(debug_assertions) || std::env::var("SPIKARD_DEBUG").is_ok() || std::env::var("DEBUG").is_ok();
+
+    eprintln!(
+        "[spikard-http::debug] init() called, cfg!(debug_assertions)={}, DEBUG={}, enabled={}",
+        cfg!(debug_assertions),
+        std::env::var("DEBUG").is_ok(),
+        enabled
+    );
+
+    DEBUG_ENABLED.store(enabled, Ordering::Relaxed);
+
+    if enabled {
+        eprintln!("[spikard-http] Debug logging enabled");
+    }
+}
+
+/// Check if debug logging is enabled
+#[inline]
+pub fn is_enabled() -> bool {
+    DEBUG_ENABLED.load(Ordering::Relaxed)
+}
+
+/// Log a debug message if debugging is enabled
+#[macro_export]
+macro_rules! debug_log {
+    ($($arg:tt)*) => {
+        if $crate::debug::is_enabled() {
+            eprintln!("[spikard-http] {}", format!($($arg)*));
+        }
+    };
+}
+
+/// Log a debug message with a specific module/component name
+#[macro_export]
+macro_rules! debug_log_module {
+    ($module:expr, $($arg:tt)*) => {
+        if $crate::debug::is_enabled() {
+            eprintln!("[spikard-http::{}] {}", $module, format!($($arg)*));
+        }
+    };
+}
+
+/// Log a debug value with pretty-printing
+#[macro_export]
+macro_rules! debug_log_value {
+    ($name:expr, $value:expr) => {
+        if $crate::debug::is_enabled() {
+            eprintln!("[spikard-http] {} = {:?}", $name, $value);
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+    use std::sync::atomic::Ordering;
+
+    static FLAG_LOCK: Mutex<()> = Mutex::new(());
+
+    struct DebugFlagGuard {
+        previous_flag: bool,
+        previous_env: Option<String>,
+    }
+
+    impl Drop for DebugFlagGuard {
+        fn drop(&mut self) {
+            DEBUG_ENABLED.store(self.previous_flag, Ordering::Relaxed);
+            if let Some(prev) = &self.previous_env {
+                unsafe { std::env::set_var("SPIKARD_DEBUG", prev) };
+            } else {
+                unsafe { std::env::remove_var("SPIKARD_DEBUG") };
+            }
+        }
+    }
+
+    #[test]
+    fn init_sets_debug_enabled_in_tests() {
+        let _lock = FLAG_LOCK.lock().unwrap();
+        let previous = DEBUG_ENABLED.load(Ordering::Relaxed);
+        let previous_env = std::env::var("SPIKARD_DEBUG").ok();
+        let _guard = DebugFlagGuard {
+            previous_flag: previous,
+            previous_env,
+        };
+
+        unsafe { std::env::set_var("SPIKARD_DEBUG", "1") };
+
+        init();
+        assert!(is_enabled(), "init should enable debug when SPIKARD_DEBUG is set");
+    }
+
+    #[test]
+    fn macros_follow_debug_flag() {
+        let _lock = FLAG_LOCK.lock().unwrap();
+        let previous = DEBUG_ENABLED.load(Ordering::Relaxed);
+        let previous_env = std::env::var("SPIKARD_DEBUG").ok();
+        let _guard = DebugFlagGuard {
+            previous_flag: previous,
+            previous_env,
+        };
+
+        DEBUG_ENABLED.store(false, Ordering::Relaxed);
+        debug_log!("disabled branch");
+        debug_log_module!("core", "disabled");
+        debug_log_value!("counter", 0_u8);
+        assert!(!is_enabled());
+
+        DEBUG_ENABLED.store(true, Ordering::Relaxed);
+        debug_log!("enabled branch {}", 1);
+        debug_log_module!("core", "enabled");
+        debug_log_value!("counter", 2_i32);
+        assert!(is_enabled());
+    }
+}