spikard 0.3.6 → 0.5.0

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

@@ -4,26 +4,37 @@
 //! including JSON conversion, string conversion, and request/response building.
 
 #![allow(dead_code)]
+#![deny(clippy::unwrap_used)]
 
 use bytes::Bytes;
 use magnus::prelude::*;
-use magnus::{Error, RArray, RHash, RString, Ruby, TryConvert, Value};
+use magnus::{Error, RArray, RHash, RString, Ruby, Symbol, TryConvert, Value};
 use serde_json::Value as JsonValue;
-use spikard_http::problem::ProblemDetails;
+use spikard_core::problem::ProblemDetails;
 use spikard_http::testing::MultipartFilePart;
 use std::collections::HashMap;
 
-use crate::test_client::{RequestBody, RequestConfig, TestResponseData};
+use crate::testing::client::{RequestBody, RequestConfig, TestResponseData};
 
 /// Convert a Ruby value to JSON.
 ///
-/// Uses Ruby's JSON.generate method to serialize the Ruby object
-/// and then parses the result.
+/// Fast-path converts common Ruby types directly in Rust to avoid
+/// `JSON.generate` + `serde_json::from_str` overhead.
+///
+/// Falls back to Ruby JSON for unsupported types to preserve behavior.
 pub fn ruby_value_to_json(ruby: &Ruby, json_module: Value, value: Value) -> Result<JsonValue, Error> {
     if value.is_nil() {
         return Ok(JsonValue::Null);
     }
 
+    if let Some(converted) = ruby_value_to_json_fast(ruby, json_module, value, 0)? {
+        return Ok(converted);
+    }
+
+    ruby_value_to_json_fallback(ruby, json_module, value)
+}
+
+fn ruby_value_to_json_fallback(ruby: &Ruby, json_module: Value, value: Value) -> Result<JsonValue, Error> {
     let json_string: String = json_module.funcall("generate", (value,))?;
     serde_json::from_str(&json_string).map_err(|err| {
         Error::new(
@@ -33,6 +44,95 @@ pub fn ruby_value_to_json(ruby: &Ruby, json_module: Value, value: Value) -> Resu
     })
 }
 
+fn ruby_value_to_json_fast(
+    ruby: &Ruby,
+    json_module: Value,
+    value: Value,
+    depth: usize,
+) -> Result<Option<JsonValue>, Error> {
+    // Cycle detection is non-trivial without tracking Ruby object IDs; a shallow
+    // recursion guard avoids worst-case behavior and defers to Ruby JSON.
+    if depth > 64 {
+        return Ok(None);
+    }
+
+    if value.is_nil() {
+        return Ok(Some(JsonValue::Null));
+    }
+
+    if value.is_kind_of(ruby.class_true_class()) {
+        return Ok(Some(JsonValue::Bool(true)));
+    }
+
+    if value.is_kind_of(ruby.class_false_class()) {
+        return Ok(Some(JsonValue::Bool(false)));
+    }
+
+    if let Ok(text) = RString::try_convert(value) {
+        let slice = unsafe { text.as_slice() };
+        return Ok(Some(JsonValue::String(String::from_utf8_lossy(slice).to_string())));
+    }
+
+    if value.is_kind_of(ruby.class_float()) {
+        let n = f64::try_convert(value)?;
+        let number = serde_json::Number::from_f64(n).ok_or_else(|| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                "Failed to convert Ruby Float to JSON number",
+            )
+        })?;
+        return Ok(Some(JsonValue::Number(number)));
+    }
+
+    if value.is_kind_of(ruby.class_integer()) {
+        if let Ok(n) = i64::try_convert(value) {
+            return Ok(Some(JsonValue::from(n)));
+        }
+        if let Ok(n) = u64::try_convert(value) {
+            return Ok(Some(JsonValue::from(n)));
+        }
+    }
+
+    if let Some(array) = RArray::from_value(value) {
+        let mut out = Vec::with_capacity(array.len());
+        for idx in 0..array.len() {
+            let item: Value = array.entry(idx as isize)?;
+            let json_item = match ruby_value_to_json_fast(ruby, json_module, item, depth + 1)? {
+                Some(v) => v,
+                None => ruby_value_to_json_fallback(ruby, json_module, item)?,
+            };
+            out.push(json_item);
+        }
+        return Ok(Some(JsonValue::Array(out)));
+    }
+
+    if let Some(hash) = RHash::from_value(value) {
+        let mut map = serde_json::Map::with_capacity(hash.len());
+        hash.foreach(|key: Value, val: Value| {
+            let key_str = if let Ok(key_text) = RString::try_convert(key) {
+                let slice = unsafe { key_text.as_slice() };
+                String::from_utf8_lossy(slice).to_string()
+            } else if let Ok(sym) = Symbol::try_convert(key) {
+                sym.name()?.into_owned()
+            } else {
+                let key_as_str: String = key.funcall("to_s", ())?;
+                key_as_str
+            };
+
+            let json_val = match ruby_value_to_json_fast(ruby, json_module, val, depth + 1)? {
+                Some(v) => v,
+                None => ruby_value_to_json_fallback(ruby, json_module, val)?,
+            };
+
+            map.insert(key_str, json_val);
+            Ok(magnus::r_hash::ForEach::Continue)
+        })?;
+        return Ok(Some(JsonValue::Object(map)));
+    }
+
+    Ok(None)
+}
+
 /// Convert JSON to a Ruby value.
 ///
 /// Recursively converts JSON types to native Ruby types:
@@ -74,20 +174,20 @@ pub fn json_to_ruby_with_uploads(
         }
         JsonValue::String(str_val) => Ok(ruby.str_new(str_val).as_value()),
         JsonValue::Array(items) => {
-            let array = ruby.ary_new();
+            let array = ruby.ary_new_capa(items.len());
             for item in items {
                 array.push(json_to_ruby_with_uploads(ruby, item, upload_file_class)?)?;
             }
             Ok(array.as_value())
         }
         JsonValue::Object(map) => {
-            if let Some(upload_file) = upload_file_class {
-                if let Some(upload) = try_build_upload_file(ruby, upload_file, map)? {
-                    return Ok(upload);
-                }
+            if let Some(upload_file) = upload_file_class
+                && let Some(upload) = try_build_upload_file(ruby, upload_file, map)?
+            {
+                return Ok(upload);
             }
 
-            let hash = ruby.hash_new();
+            let hash = ruby.hash_new_capa(map.len());
             for (key, item) in map {
                 hash.aset(
                     ruby.str_new(key),
@@ -101,7 +201,7 @@ pub fn json_to_ruby_with_uploads(
 
 /// Convert a HashMap to a Ruby Hash.
 pub fn map_to_ruby_hash(ruby: &Ruby, map: &HashMap<String, String>) -> Result<Value, Error> {
-    let hash = ruby.hash_new();
+    let hash = ruby.hash_new_capa(map.len());
     for (key, value) in map {
         hash.aset(ruby.str_new(key), ruby.str_new(value))?;
     }
@@ -110,9 +210,9 @@ pub fn map_to_ruby_hash(ruby: &Ruby, map: &HashMap<String, String>) -> Result<Va
 
 /// Convert a HashMap of Vecs to a Ruby Hash with array values.
 pub fn multimap_to_ruby_hash(ruby: &Ruby, map: &HashMap<String, Vec<String>>) -> Result<Value, Error> {
-    let hash = ruby.hash_new();
+    let hash = ruby.hash_new_capa(map.len());
     for (key, values) in map {
-        let array = ruby.ary_new();
+        let array = ruby.ary_new_capa(values.len());
         for value in values {
             array.push(ruby.str_new(value))?;
         }
@@ -165,10 +265,6 @@ fn try_build_upload_file(
 /// Accepts either String or Array of bytes.
 pub fn ruby_value_to_bytes(value: Value) -> Result<Bytes, std::io::Error> {
     if let Ok(str_value) = RString::try_convert(value) {
-        // SAFETY: Magnus guarantees RString::as_slice() returns valid UTF-8 (or binary)
-        // bytes for the lifetime of the RString. The slice is only used within this
-        // function scope to copy into a Bytes buffer, and does not outlive the RString
-        // reference. The copy_from_slice operation is safe for the borrowed data.
         let slice = unsafe { str_value.as_slice() };
         return Ok(Bytes::copy_from_slice(slice));
     }
@@ -296,10 +392,15 @@ pub fn parse_request_config(ruby: &Ruby, options: Value) -> Result<RequestConfig
     };
 
     let files_opt = get_kw(ruby, hash, "files");
-    let has_files = files_opt.is_some() && !files_opt.unwrap().is_nil();
+    let has_files = files_opt.as_ref().is_some_and(|f| !f.is_nil());
 
     let body = if has_files {
-        let files_value = files_opt.unwrap();
+        let files_value = files_opt.ok_or_else(|| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                "Files option should be Some if has_files is true",
+            )
+        })?;
         let files = extract_files(ruby, files_value)?;
 
         let mut form_data = Vec::new();

data/vendor/crates/spikard-rb/src/di/builder.rs

@@ -0,0 +1,100 @@
+//! Dependency injection container building from Ruby objects.
+//!
+//! This module handles constructing DependencyContainer instances from Ruby
+//! hashes and factories.
+
+use magnus::prelude::*;
+use magnus::{Error, RHash, Ruby, TryConvert, Value, r_hash::ForEach};
+use spikard_core::di::DependencyContainer;
+use std::sync::Arc;
+
+/// Build a DependencyContainer from Ruby dependency definitions
+pub fn build_dependency_container(ruby: &Ruby, dependencies: Value) -> Result<DependencyContainer, Error> {
+    if dependencies.is_nil() {
+        return Ok(DependencyContainer::new());
+    }
+
+    let mut container = DependencyContainer::new();
+    let deps_hash = RHash::try_convert(dependencies)?;
+
+    deps_hash.foreach(|key: String, value: Value| -> Result<ForEach, Error> {
+        if let Ok(dep_hash) = RHash::try_convert(value) {
+            let dep_type: Option<String> = get_kw(ruby, dep_hash, "type").and_then(|v| {
+                if let Ok(sym) = magnus::Symbol::try_convert(v) {
+                    Some(sym.name().ok()?.to_string())
+                } else {
+                    String::try_convert(v).ok()
+                }
+            });
+
+            match dep_type.as_deref() {
+                Some("factory") => {
+                    let factory = get_kw(ruby, dep_hash, "factory")
+                        .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Factory missing 'factory' key"))?;
+
+                    let depends_on: Vec<String> = get_kw(ruby, dep_hash, "depends_on")
+                        .and_then(|v| Vec::<String>::try_convert(v).ok())
+                        .unwrap_or_default();
+
+                    let singleton: bool = get_kw(ruby, dep_hash, "singleton")
+                        .and_then(|v| bool::try_convert(v).ok())
+                        .unwrap_or(false);
+
+                    let cacheable: bool = get_kw(ruby, dep_hash, "cacheable")
+                        .and_then(|v| bool::try_convert(v).ok())
+                        .unwrap_or(true);
+
+                    let factory_dep =
+                        crate::di::RubyFactoryDependency::new(key.clone(), factory, depends_on, singleton, cacheable);
+
+                    container.register(key.clone(), Arc::new(factory_dep)).map_err(|e| {
+                        Error::new(
+                            ruby.exception_runtime_error(),
+                            format!("Failed to register factory '{}': {}", key, e),
+                        )
+                    })?;
+                }
+                Some("value") => {
+                    let value_data = get_kw(ruby, dep_hash, "value").ok_or_else(|| {
+                        Error::new(ruby.exception_runtime_error(), "Value dependency missing 'value' key")
+                    })?;
+
+                    let value_dep = crate::di::RubyValueDependency::new(key.clone(), value_data);
+
+                    container.register(key.clone(), Arc::new(value_dep)).map_err(|e| {
+                        Error::new(
+                            ruby.exception_runtime_error(),
+                            format!("Failed to register value '{}': {}", key, e),
+                        )
+                    })?;
+                }
+                _ => {
+                    return Err(Error::new(
+                        ruby.exception_runtime_error(),
+                        format!("Invalid dependency type for '{}'", key),
+                    ));
+                }
+            }
+        } else {
+            let value_dep = crate::di::RubyValueDependency::new(key.clone(), value);
+            container.register(key.clone(), Arc::new(value_dep)).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to register value '{}': {}", key, e),
+                )
+            })?;
+        }
+
+        Ok(ForEach::Continue)
+    })?;
+
+    Ok(container)
+}
+
+/// Get a keyword argument from a Ruby hash (returns None if not present or nil)
+fn get_kw(ruby: &Ruby, hash: RHash, name: &str) -> Option<Value> {
+    match hash.get(ruby.to_symbol(name)) {
+        Some(v) if !v.is_nil() => Some(v),
+        _ => None,
+    }
+}

data/vendor/crates/spikard-rb/src/{di.rs → di/mod.rs}

@@ -5,6 +5,10 @@
 
 #![allow(dead_code)]
 
+pub mod builder;
+
+pub use builder::build_dependency_container;
+
 use http::Request;
 use magnus::prelude::*;
 use magnus::value::{InnerValue, Opaque};
@@ -39,7 +43,7 @@ impl Dependency for RubyValueDependency {
     }
 
     fn depends_on(&self) -> Vec<String> {
-        Vec::new() // Value dependencies have no dependencies
+        Vec::new()
     }
 
     fn resolve(
@@ -50,12 +54,10 @@ impl Dependency for RubyValueDependency {
     ) -> Pin<Box<dyn std::future::Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>>
     {
         Box::pin(async move {
-            // Get the Ruby value
             let ruby = Ruby::get().map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?;
 
             let value = self.value.get_inner_with(&ruby);
 
-            // Convert to JSON and back to make it Send + Sync
             let json_value = ruby_value_to_json(&ruby, value)
                 .map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?;
 
@@ -64,7 +66,7 @@ impl Dependency for RubyValueDependency {
     }
 
     fn singleton(&self) -> bool {
-        true // Value dependencies are always singletons
+        true
     }
 
     fn cacheable(&self) -> bool {
@@ -111,30 +113,23 @@ impl Dependency for RubyFactoryDependency {
         resolved: &ResolvedDependencies,
     ) -> Pin<Box<dyn std::future::Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>>
     {
-        // Clone data needed in async block
         let factory = self.factory;
         let depends_on = self.depends_on.clone();
         let key = self.key.clone();
         let is_singleton = self.singleton;
         let resolved_clone = resolved.clone();
 
-        // Extract resolved dependencies now (before async)
-        // Need to handle both JsonValue and RubyValueWrapper types
         let resolved_deps: Vec<(String, JsonValue)> = depends_on
             .iter()
             .filter_map(|dep_key| {
-                // Try JsonValue first
                 if let Some(json_value) = resolved.get::<JsonValue>(dep_key) {
                     return Some((dep_key.clone(), (*json_value).clone()));
                 }
-                // Try RubyValueWrapper (for singletons)
-                if let Some(wrapper) = resolved.get::<RubyValueWrapper>(dep_key) {
-                    // Convert wrapper to JSON synchronously
-                    if let Ok(ruby) = Ruby::get()
-                        && let Ok(json) = wrapper.to_json(&ruby)
-                    {
-                        return Some((dep_key.clone(), json));
-                    }
+                if let Some(wrapper) = resolved.get::<RubyValueWrapper>(dep_key)
+                    && let Ok(ruby) = Ruby::get()
+                    && let Ok(json) = wrapper.to_json(&ruby)
+                {
+                    return Some((dep_key.clone(), json));
                 }
                 None
             })
@@ -143,15 +138,9 @@ impl Dependency for RubyFactoryDependency {
         Box::pin(async move {
             let ruby = Ruby::get().map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?;
 
-            // Build positional arguments array from resolved dependencies
-            // Dependencies must be passed in the order specified by depends_on
-            // Important: preserve the order from depends_on, not from resolved_deps iteration
             let args: Result<Vec<Value>, DependencyError> = depends_on
                 .iter()
-                .filter_map(|dep_key| {
-                    // Find this dependency in resolved_deps
-                    resolved_deps.iter().find(|(k, _)| k == dep_key).map(|(_, v)| v)
-                })
+                .filter_map(|dep_key| resolved_deps.iter().find(|(k, _)| k == dep_key).map(|(_, v)| v))
                 .map(|dep_value| {
                     json_to_ruby(&ruby, dep_value).map_err(|e| DependencyError::ResolutionFailed {
                         message: format!("Failed to convert dependency value: {}", e),
@@ -160,10 +149,8 @@ impl Dependency for RubyFactoryDependency {
                 .collect();
             let args = args?;
 
-            // Call the factory Proc with positional arguments
             let factory_value = factory.get_inner_with(&ruby);
 
-            // Check if factory responds to call
             if !factory_value
                 .respond_to("call", false)
                 .map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?
@@ -173,10 +160,7 @@ impl Dependency for RubyFactoryDependency {
                 });
             }
 
-            // Call factory with positional arguments
-            // Use a Ruby helper to call with splatted arguments
             let result: Value = if !args.is_empty() {
-                // Create a Ruby array of arguments
                 let args_array = ruby.ary_new();
                 for arg in &args {
                     args_array.push(*arg).map_err(|e| DependencyError::ResolutionFailed {
@@ -184,8 +168,6 @@ impl Dependency for RubyFactoryDependency {
                     })?;
                 }
 
-                // Use Ruby's send with * to splat arguments
-                // Equivalent to: factory_value.call(*args_array)
                 let splat_lambda = ruby
                     .eval::<Value>("lambda { |proc, args| proc.call(*args) }")
                     .map_err(|e| DependencyError::ResolutionFailed {
@@ -200,7 +182,6 @@ impl Dependency for RubyFactoryDependency {
                 message: format!("Failed to call factory for '{}': {}", key, e),
             })?;
 
-            // Check if result is an array with cleanup callback (Ruby pattern: [resource, cleanup_proc])
             let (value_to_convert, cleanup_callback) = if result.is_kind_of(ruby.class_array()) {
                 let array = magnus::RArray::from_value(result).ok_or_else(|| DependencyError::ResolutionFailed {
                     message: format!("Failed to convert result to array for '{}'", key),
@@ -208,50 +189,40 @@ impl Dependency for RubyFactoryDependency {
 
                 let len = array.len();
                 if len == 2 {
-                    // Extract the resource (first element)
                     let resource: Value = array.entry(0).map_err(|e| DependencyError::ResolutionFailed {
                         message: format!("Failed to extract resource from array for '{}': {}", key, e),
                     })?;
 
-                    // Extract cleanup callback (second element)
                     let cleanup: Value = array.entry(1).map_err(|e| DependencyError::ResolutionFailed {
                         message: format!("Failed to extract cleanup callback for '{}': {}", key, e),
                     })?;
 
                     (resource, Some(cleanup))
                 } else {
-                    // Not a cleanup pattern, use the array as-is
                     (result, None)
                 }
             } else {
-                // Not an array, use the value as-is
                 (result, None)
             };
 
-            // Register cleanup callback if present
             if let Some(cleanup_proc) = cleanup_callback {
                 let cleanup_opaque = Opaque::from(cleanup_proc);
 
                 resolved_clone.add_cleanup_task(Box::new(move || {
                     Box::pin(async move {
-                        // Get Ruby runtime and call cleanup proc
                         if let Ok(ruby) = Ruby::get() {
                             let proc = cleanup_opaque.get_inner_with(&ruby);
-                            // Call the cleanup proc - ignore errors during cleanup
                             let _ = proc.funcall::<_, _, Value>("call", ());
                         }
                     })
                 }));
             }
 
-            // For singleton dependencies, store Ruby value wrapper to preserve mutations
-            // For non-singleton, convert to JSON immediately (no need to preserve mutations)
             if is_singleton {
                 let wrapper = RubyValueWrapper::new(value_to_convert);
                 return Ok(Arc::new(wrapper) as Arc<dyn Any + Send + Sync>);
             }
 
-            // Convert result to JSON for non-singleton dependencies
             let json_value = ruby_value_to_json(&ruby, value_to_convert)
                 .map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?;
 
@@ -305,8 +276,6 @@ impl RubyValueWrapper {
     }
 }
 
-// Safety: Opaque<Value> is designed to be Send + Sync by magnus
-// It holds a stable pointer that's safe to share across threads
 unsafe impl Send for RubyValueWrapper {}
 unsafe impl Sync for RubyValueWrapper {}
 
@@ -374,7 +343,6 @@ pub fn extract_di_options(ruby: &Ruby, options: Value) -> Result<(Vec<String>, b
 
     let hash = RHash::try_convert(options)?;
 
-    // Extract depends_on
     let depends_on = if let Some(deps_value) = get_kw(ruby, hash, "depends_on") {
         if deps_value.is_nil() {
             Vec::new()
@@ -385,14 +353,12 @@ pub fn extract_di_options(ruby: &Ruby, options: Value) -> Result<(Vec<String>, b
         Vec::new()
     };
 
-    // Extract singleton (default false)
     let singleton = if let Some(singleton_value) = get_kw(ruby, hash, "singleton") {
         bool::try_convert(singleton_value).unwrap_or(false)
     } else {
         false
     };
 
-    // Extract cacheable (default true)
     let cacheable = if let Some(cacheable_value) = get_kw(ruby, hash, "cacheable") {
         bool::try_convert(cacheable_value).unwrap_or(true)
     } else {