spikard 0.12.0 → 0.15.2

data/vendor/crates/spikard-rb/src/request.rs

@@ -1,439 +0,0 @@
-//! Native Request object for Ruby handlers.
-//!
-//! Ruby benchmarks frequently access only a subset of request fields. Building a full
-//! Ruby Hash for every request eagerly converts headers/cookies/query/etc even when
-//! unused. This module provides a native `Spikard::Native::Request` that lazily
-//! materialises Ruby values on demand and caches them for subsequent access.
-
-#![deny(clippy::unwrap_used)]
-
-use bytes::Bytes;
-use magnus::prelude::*;
-use magnus::value::InnerValue;
-use magnus::value::LazyId;
-use magnus::value::Opaque;
-use magnus::{Error, RHash, RString, Ruby, Symbol, Value, gc::Marker};
-use serde_json::{Map as JsonMap, Value as JsonValue};
-use spikard_http::RequestData;
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use crate::conversion::{json_to_ruby_with_uploads, map_to_ruby_hash, multimap_to_ruby_hash};
-use crate::metadata::json_to_ruby;
-
-#[derive(Default)]
-struct RequestCache {
-    method: Option<Opaque<Value>>,
-    path: Option<Opaque<Value>>,
-    path_params: Option<Opaque<Value>>,
-    query: Option<Opaque<Value>>,
-    raw_query: Option<Opaque<Value>>,
-    headers: Option<Opaque<Value>>,
-    cookies: Option<Opaque<Value>>,
-    body: Option<Opaque<Value>>,
-    raw_body: Option<Opaque<Value>>,
-    params: Option<Opaque<Value>>,
-    to_h: Option<Opaque<Value>>,
-}
-
-#[magnus::wrap(class = "Spikard::Native::Request", free_immediately, mark)]
-pub struct NativeRequest {
-    method: String,
-    path: String,
-    path_params: Arc<HashMap<String, String>>,
-    query_params: JsonValue,
-    raw_query_params: Arc<HashMap<String, Vec<String>>>,
-    body: JsonValue,
-    raw_body: Option<Bytes>,
-    headers: Arc<HashMap<String, String>>,
-    cookies: Arc<HashMap<String, String>>,
-    validated_params: Option<JsonValue>,
-    /// Upload file class for wrapping file upload objects in the body.
-    /// When present, `json_to_ruby_with_uploads` is used instead of `json_to_ruby`.
-    upload_file_class: Option<Opaque<Value>>,
-    cache: RefCell<RequestCache>,
-}
-
-static KEY_METHOD: LazyId = LazyId::new("method");
-static KEY_PATH: LazyId = LazyId::new("path");
-static KEY_PATH_PARAMS: LazyId = LazyId::new("path_params");
-static KEY_QUERY: LazyId = LazyId::new("query");
-static KEY_RAW_QUERY: LazyId = LazyId::new("raw_query");
-static KEY_HEADERS: LazyId = LazyId::new("headers");
-static KEY_COOKIES: LazyId = LazyId::new("cookies");
-static KEY_BODY: LazyId = LazyId::new("body");
-static KEY_RAW_BODY: LazyId = LazyId::new("raw_body");
-static KEY_PARAMS: LazyId = LazyId::new("params");
-
-impl NativeRequest {
-    /// Convert RequestData to NativeRequest with Arc unwrapping for lazy cache.
-    ///
-    /// # Arc Unwrapping Strategy
-    ///
-    /// `spikard_http::RequestData` has Arc-wrapped fields for cheap cloning:
-    /// - `query_params: Arc<Value>`
-    /// - `body: Arc<Value>`
-    /// - `validated_params: Option<Arc<Value>>`
-    ///
-    /// This method unwraps these Arc fields into plain Values for storage in NativeRequest,
-    /// using `Arc::try_unwrap()` to eliminate the clone when the Arc has a unique reference.
-    ///
-    /// ## Pattern: Arc::try_unwrap Optimization
-    ///
-    /// ```text
-    /// Arc::try_unwrap(arc)
-    ///   → Ok(Value)      if Arc has unique ref (no other clones)
-    ///   → Err(Arc)       if Arc has multiple refs
-    ///
-    /// Result: eliminates guaranteed clone ~95% of time (single request flow)
-    /// Fallback: clones only when Arc is shared (rare case)
-    /// ```
-    ///
-    /// ## Why This Works with Lazy Caching
-    ///
-    /// The lazy cache pattern in this struct caches converted Ruby values, not the original JSON.
-    /// Once unwrapped here, the Arc-wrapped Values are never unwrapped again:
-    ///
-    /// 1. `RequestData` arrives with Arc-wrapped JSON (from HTTP layer)
-    /// 2. `from_request_data()` unwraps Arc → stores plain JsonValue
-    /// 3. Cache stores converted Ruby values (not JSON)
-    /// 4. No further Arc operations needed in cache methods
-    ///
-    /// This is a **one-time operation per request**, not repeated per field access.
-    ///
-    /// ## Performance Impact
-    ///
-    /// - Typical: 5-10% faster (eliminates clone for ~95% of requests)
-    /// - Worst case: Same as clone (if Arc is shared, which rarely happens)
-    /// - Best case: Pure move, zero copy (Arc has unique reference)
-    pub(crate) fn from_request_data(
-        request_data: RequestData,
-        validated_params: Option<JsonValue>,
-        upload_file_class: Option<Opaque<Value>>,
-    ) -> Self {
-        let RequestData {
-            path_params,
-            query_params,
-            raw_query_params,
-            body,
-            raw_body,
-            headers,
-            cookies,
-            method,
-            path,
-            ..
-        } = request_data;
-
-        Self {
-            method,
-            path,
-            path_params,
-            // Arc::try_unwrap eliminates clone when possible (most requests have unique Arc ref)
-            query_params: Arc::try_unwrap(query_params).unwrap_or_else(|arc| (*arc).clone()),
-            raw_query_params,
-            // Arc::try_unwrap eliminates clone when possible (most requests have unique Arc ref)
-            body: Arc::try_unwrap(body).unwrap_or_else(|arc| (*arc).clone()),
-            raw_body,
-            headers,
-            cookies,
-            validated_params,
-            upload_file_class,
-            cache: RefCell::new(RequestCache::default()),
-        }
-    }
-
-    fn cache_get(cache: Option<&Opaque<Value>>, ruby: &Ruby) -> Option<Value> {
-        cache.map(|v| v.get_inner_with(ruby))
-    }
-
-    fn cache_set(slot: &mut Option<Opaque<Value>>, value: Value) -> Value {
-        *slot = Some(Opaque::from(value));
-        value
-    }
-
-    pub(crate) fn method(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(value) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.method.as_ref(), ruby)
-        } {
-            return Ok(value);
-        }
-        let value = ruby.str_new(&this.method).as_value();
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.method, value))
-    }
-
-    pub(crate) fn path(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(value) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.path.as_ref(), ruby)
-        } {
-            return Ok(value);
-        }
-        let value = ruby.str_new(&this.path).as_value();
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.path, value))
-    }
-
-    pub(crate) fn path_params(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(cached) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.path_params.as_ref(), ruby)
-        } {
-            return Ok(cached);
-        }
-        if let Some(validated) = &this.validated_params
-            && let Some(validated_map) = validated.as_object()
-        {
-            let mut subset = JsonMap::new();
-            for key in this.path_params.keys() {
-                if let Some(value) = validated_map.get(key) {
-                    subset.insert(key.clone(), value.clone());
-                }
-            }
-            if !subset.is_empty() {
-                let value = json_to_ruby(ruby, &JsonValue::Object(subset))?;
-                let mut cache = this.cache.borrow_mut();
-                return Ok(Self::cache_set(&mut cache.path_params, value));
-            }
-        }
-        let value = map_to_ruby_hash(ruby, this.path_params.as_ref())?;
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.path_params, value))
-    }
-
-    pub(crate) fn query(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(cached) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.query.as_ref(), ruby)
-        } {
-            return Ok(cached);
-        }
-        if let Some(validated) = &this.validated_params
-            && let Some(validated_map) = validated.as_object()
-        {
-            let mut subset = JsonMap::new();
-            if !this.raw_query_params.is_empty() {
-                for key in this.raw_query_params.keys() {
-                    if let Some(value) = validated_map.get(key) {
-                        subset.insert(key.clone(), value.clone());
-                    }
-                }
-            } else if let Some(query_map) = this.query_params.as_object() {
-                for key in query_map.keys() {
-                    if let Some(value) = validated_map.get(key) {
-                        subset.insert(key.clone(), value.clone());
-                    }
-                }
-            }
-
-            if !subset.is_empty() {
-                let value = json_to_ruby(ruby, &JsonValue::Object(subset))?;
-                let mut cache = this.cache.borrow_mut();
-                return Ok(Self::cache_set(&mut cache.query, value));
-            }
-        }
-        let value = json_to_ruby(ruby, &this.query_params)?;
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.query, value))
-    }
-
-    pub(crate) fn raw_query(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(cached) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.raw_query.as_ref(), ruby)
-        } {
-            return Ok(cached);
-        }
-        let value = multimap_to_ruby_hash(ruby, this.raw_query_params.as_ref())?;
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.raw_query, value))
-    }
-
-    pub(crate) fn headers(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(cached) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.headers.as_ref(), ruby)
-        } {
-            return Ok(cached);
-        }
-        let value = map_to_ruby_hash(ruby, this.headers.as_ref())?;
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.headers, value))
-    }
-
-    pub(crate) fn cookies(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(cached) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.cookies.as_ref(), ruby)
-        } {
-            return Ok(cached);
-        }
-        let value = map_to_ruby_hash(ruby, this.cookies.as_ref())?;
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.cookies, value))
-    }
-
-    pub(crate) fn body(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(cached) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.body.as_ref(), ruby)
-        } {
-            return Ok(cached);
-        }
-        let upload_cls = this.upload_file_class.as_ref().map(|o| o.get_inner_with(ruby));
-        let value = json_to_ruby_with_uploads(ruby, &this.body, upload_cls.as_ref())?;
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.body, value))
-    }
-
-    pub(crate) fn raw_body(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(cached) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.raw_body.as_ref(), ruby)
-        } {
-            return Ok(cached);
-        }
-        let value = match &this.raw_body {
-            Some(bytes) => ruby.str_from_slice(bytes.as_ref()).as_value(),
-            None => ruby.qnil().as_value(),
-        };
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.raw_body, value))
-    }
-
-    pub(crate) fn params(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(value) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.params.as_ref(), ruby)
-        } {
-            return Ok(value);
-        }
-
-        let value = if let Some(validated) = &this.validated_params {
-            json_to_ruby(ruby, validated)?
-        } else {
-            let params = ruby.hash_new();
-            if let Some(hash) = RHash::from_value(Self::path_params(ruby, this)?) {
-                let _: Value = params.funcall("merge!", (hash,))?;
-            }
-            if let Some(hash) = RHash::from_value(Self::query(ruby, this)?) {
-                let _: Value = params.funcall("merge!", (hash,))?;
-            }
-            if let Some(hash) = RHash::from_value(Self::headers(ruby, this)?) {
-                let _: Value = params.funcall("merge!", (hash,))?;
-            }
-            if let Some(hash) = RHash::from_value(Self::cookies(ruby, this)?) {
-                let _: Value = params.funcall("merge!", (hash,))?;
-            }
-            params.as_value()
-        };
-
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.params, value))
-    }
-
-    pub(crate) fn to_h(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        if let Some(value) = {
-            let cache = this.cache.borrow();
-            Self::cache_get(cache.to_h.as_ref(), ruby)
-        } {
-            return Ok(value);
-        }
-
-        let hash = ruby.hash_new_capa(10);
-        hash.aset(ruby.intern("method"), Self::method(ruby, this)?)?;
-        hash.aset(ruby.intern("path"), Self::path(ruby, this)?)?;
-        hash.aset(ruby.intern("path_params"), Self::path_params(ruby, this)?)?;
-        hash.aset(ruby.intern("query"), Self::query(ruby, this)?)?;
-        hash.aset(ruby.intern("raw_query"), Self::raw_query(ruby, this)?)?;
-        hash.aset(ruby.intern("headers"), Self::headers(ruby, this)?)?;
-        hash.aset(ruby.intern("cookies"), Self::cookies(ruby, this)?)?;
-        hash.aset(ruby.intern("body"), Self::body(ruby, this)?)?;
-        hash.aset(ruby.intern("raw_body"), Self::raw_body(ruby, this)?)?;
-        hash.aset(ruby.intern("params"), Self::params(ruby, this)?)?;
-
-        let mut cache = this.cache.borrow_mut();
-        Ok(Self::cache_set(&mut cache.to_h, hash.as_value()))
-    }
-
-    pub(crate) fn index(ruby: &Ruby, this: &Self, key: Value) -> Result<Value, Error> {
-        if let Ok(sym) = Symbol::try_convert(key) {
-            return if sym == KEY_METHOD {
-                Self::method(ruby, this)
-            } else if sym == KEY_PATH {
-                Self::path(ruby, this)
-            } else if sym == KEY_PATH_PARAMS {
-                Self::path_params(ruby, this)
-            } else if sym == KEY_QUERY {
-                Self::query(ruby, this)
-            } else if sym == KEY_RAW_QUERY {
-                Self::raw_query(ruby, this)
-            } else if sym == KEY_HEADERS {
-                Self::headers(ruby, this)
-            } else if sym == KEY_COOKIES {
-                Self::cookies(ruby, this)
-            } else if sym == KEY_BODY {
-                Self::body(ruby, this)
-            } else if sym == KEY_RAW_BODY {
-                Self::raw_body(ruby, this)
-            } else if sym == KEY_PARAMS {
-                Self::params(ruby, this)
-            } else {
-                Ok(ruby.qnil().as_value())
-            };
-        }
-
-        if let Ok(text) = RString::try_convert(key) {
-            // SAFETY: We only borrow the slice for the duration of this match
-            // block and never mutate the RString. The GVL is held, so no other
-            // Ruby thread can modify or move the string's backing memory.
-            let slice = unsafe { text.as_slice() };
-            return match slice {
-                b"method" => Self::method(ruby, this),
-                b"path" => Self::path(ruby, this),
-                b"path_params" => Self::path_params(ruby, this),
-                b"query" => Self::query(ruby, this),
-                b"raw_query" => Self::raw_query(ruby, this),
-                b"headers" => Self::headers(ruby, this),
-                b"cookies" => Self::cookies(ruby, this),
-                b"body" => Self::body(ruby, this),
-                b"raw_body" => Self::raw_body(ruby, this),
-                b"params" => Self::params(ruby, this),
-                _ => Ok(ruby.qnil().as_value()),
-            };
-        }
-
-        Ok(ruby.qnil().as_value())
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn mark(&self, marker: &Marker) {
-        if let Ok(ruby) = Ruby::get() {
-            let cache = self.cache.borrow();
-            for handle in [
-                &cache.method,
-                &cache.path,
-                &cache.path_params,
-                &cache.query,
-                &cache.raw_query,
-                &cache.headers,
-                &cache.cookies,
-                &cache.body,
-                &cache.raw_body,
-                &cache.params,
-                &cache.to_h,
-            ]
-            .into_iter()
-            .filter_map(|value| value.as_ref())
-            {
-                marker.mark(handle.get_inner_with(&ruby));
-            }
-
-            if let Some(ref cls) = self.upload_file_class {
-                marker.mark(cls.get_inner_with(&ruby));
-            }
-        }
-    }
-}

data/vendor/crates/spikard-rb/src/runtime/mod.rs

@@ -1,5 +0,0 @@
-//! HTTP server runtime initialization and management.
-
-pub mod server_runner;
-
-pub use server_runner::{normalize_route_metadata, run_server};