spikard 0.13.0 → 0.15.2

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

@@ -1,100 +0,0 @@
-//! 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/mod.rs

@@ -1,410 +0,0 @@
-//! Ruby dependency injection implementations
-//!
-//! This module provides Ruby-specific implementations of the Dependency trait,
-//! bridging Ruby values and Procs to the Rust DI system.
-
-#![allow(dead_code)]
-
-pub mod builder;
-
-pub use builder::build_dependency_container;
-
-use http::Request;
-use magnus::prelude::*;
-use magnus::value::{InnerValue, Opaque};
-use magnus::{Error, RArray, RHash, Ruby, TryConvert, Value};
-use serde_json::Value as JsonValue;
-use spikard_core::di::{Dependency, DependencyError, ResolvedDependencies};
-use spikard_core::request_data::RequestData;
-use std::any::Any;
-use std::pin::Pin;
-use std::sync::Arc;
-
-/// Ruby value dependency
-///
-/// Wraps a Ruby object as a static dependency value
-pub struct RubyValueDependency {
-    key: String,
-    value: Opaque<Value>,
-}
-
-impl RubyValueDependency {
-    pub fn new(key: String, value: Value) -> Self {
-        Self {
-            key,
-            value: Opaque::from(value),
-        }
-    }
-}
-
-impl Dependency for RubyValueDependency {
-    fn key(&self) -> &str {
-        &self.key
-    }
-
-    fn depends_on(&self) -> Vec<String> {
-        Vec::new()
-    }
-
-    fn resolve(
-        &self,
-        _request: &Request<()>,
-        _request_data: &RequestData,
-        _resolved: &ResolvedDependencies,
-    ) -> Pin<Box<dyn std::future::Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>>
-    {
-        Box::pin(async move {
-            let ruby = Ruby::get().map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?;
-
-            let value = self.value.get_inner_with(&ruby);
-
-            let json_value = ruby_value_to_json(&ruby, value)
-                .map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?;
-
-            Ok(Arc::new(json_value) as Arc<dyn Any + Send + Sync>)
-        })
-    }
-
-    fn singleton(&self) -> bool {
-        true
-    }
-
-    fn cacheable(&self) -> bool {
-        true
-    }
-}
-
-/// Ruby factory dependency
-///
-/// Wraps a Ruby Proc as a factory dependency
-pub struct RubyFactoryDependency {
-    key: String,
-    factory: Opaque<Value>,
-    depends_on: Vec<String>,
-    singleton: bool,
-    cacheable: bool,
-}
-
-impl RubyFactoryDependency {
-    pub fn new(key: String, factory: Value, depends_on: Vec<String>, singleton: bool, cacheable: bool) -> Self {
-        Self {
-            key,
-            factory: Opaque::from(factory),
-            depends_on,
-            singleton,
-            cacheable,
-        }
-    }
-}
-
-impl Dependency for RubyFactoryDependency {
-    fn key(&self) -> &str {
-        &self.key
-    }
-
-    fn depends_on(&self) -> Vec<String> {
-        self.depends_on.clone()
-    }
-
-    fn resolve(
-        &self,
-        _request: &Request<()>,
-        _request_data: &RequestData,
-        resolved: &ResolvedDependencies,
-    ) -> Pin<Box<dyn std::future::Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>>
-    {
-        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();
-
-        let resolved_deps: Vec<(String, JsonValue)> = depends_on
-            .iter()
-            .filter_map(|dep_key| {
-                if let Some(json_value) = resolved.get::<JsonValue>(dep_key) {
-                    return Some((dep_key.clone(), (*json_value).clone()));
-                }
-                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
-            })
-            .collect();
-
-        Box::pin(async move {
-            let ruby = Ruby::get().map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?;
-
-            let args: Result<Vec<Value>, DependencyError> = depends_on
-                .iter()
-                .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),
-                    })
-                })
-                .collect();
-            let args = args?;
-
-            let factory_value = factory.get_inner_with(&ruby);
-
-            if !factory_value
-                .respond_to("call", false)
-                .map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?
-            {
-                return Err(DependencyError::ResolutionFailed {
-                    message: format!("Dependency factory for '{}' is not callable", key),
-                });
-            }
-
-            let result: Value =
-                call_factory_with_dependencies(&ruby, factory_value, &depends_on, &args).map_err(|e| {
-                    DependencyError::ResolutionFailed {
-                        message: format!("Failed to call factory for '{}': {}", key, e),
-                    }
-                })?;
-
-            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),
-                })?;
-
-                let len = array.len();
-                if len == 2 {
-                    let resource: Value = array.entry(0).map_err(|e| DependencyError::ResolutionFailed {
-                        message: format!("Failed to extract resource from array for '{}': {}", key, e),
-                    })?;
-
-                    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 {
-                    (result, None)
-                }
-            } else {
-                (result, None)
-            };
-
-            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 {
-                        if let Ok(ruby) = Ruby::get() {
-                            let proc = cleanup_opaque.get_inner_with(&ruby);
-                            let _ = proc.funcall::<_, _, Value>("call", ());
-                        }
-                    })
-                }));
-            }
-
-            if is_singleton {
-                let wrapper = RubyValueWrapper::new(value_to_convert);
-                return Ok(Arc::new(wrapper) as Arc<dyn Any + Send + Sync>);
-            }
-
-            let json_value = ruby_value_to_json(&ruby, value_to_convert)
-                .map_err(|e| DependencyError::ResolutionFailed { message: e.to_string() })?;
-
-            Ok(Arc::new(json_value) as Arc<dyn Any + Send + Sync>)
-        })
-    }
-
-    fn singleton(&self) -> bool {
-        self.singleton
-    }
-
-    fn cacheable(&self) -> bool {
-        self.cacheable
-    }
-}
-
-fn factory_accepts_keywords(ruby: &Ruby, factory_value: Value) -> Result<bool, Error> {
-    let parameters: RArray = factory_value.funcall("parameters", ())?;
-
-    for entry in parameters.each() {
-        let entry = entry?;
-        let pair = RArray::try_convert(entry)?;
-        let param_type: String = pair.entry::<Value>(0)?.funcall("to_s", ()).map_err(|_| {
-            Error::new(
-                ruby.exception_runtime_error(),
-                "Factory parameter type must be a String or Symbol",
-            )
-        })?;
-
-        if matches!(param_type.as_str(), "key" | "keyreq" | "keyrest") {
-            return Ok(true);
-        }
-    }
-
-    Ok(false)
-}
-
-fn call_factory_with_dependencies(
-    ruby: &Ruby,
-    factory_value: Value,
-    depends_on: &[String],
-    args: &[Value],
-) -> Result<Value, Error> {
-    if args.is_empty() {
-        return factory_value.funcall("call", ());
-    }
-
-    if factory_accepts_keywords(ruby, factory_value)? {
-        let kwargs = ruby.hash_new_capa(depends_on.len());
-        for (dep_key, arg) in depends_on.iter().zip(args.iter()) {
-            kwargs.aset(ruby.to_symbol(dep_key), *arg)?;
-        }
-
-        let keyword_lambda = ruby.eval::<Value>("lambda { |callable, kwargs| callable.call(**kwargs) }")?;
-        return keyword_lambda.funcall("call", (factory_value, kwargs));
-    }
-
-    let args_array = ruby.ary_new();
-    for arg in args {
-        args_array.push(*arg)?;
-    }
-
-    let splat_lambda = ruby.eval::<Value>("lambda { |callable, args| callable.call(*args) }")?;
-    splat_lambda.funcall("call", (factory_value, args_array))
-}
-
-/// Wrapper around a Ruby Value that preserves object identity for singleton mutations
-///
-/// This stores the Ruby object itself rather than a JSON snapshot, allowing
-/// singleton dependencies to maintain mutable state across requests.
-#[derive(Clone)]
-pub struct RubyValueWrapper {
-    /// Thread-safe wrapper around Ruby Value
-    /// Opaque<Value> is Send + Sync per magnus design
-    value: Opaque<Value>,
-}
-
-impl RubyValueWrapper {
-    /// Create a new wrapper around a Ruby value
-    pub fn new(value: Value) -> Self {
-        Self {
-            value: Opaque::from(value),
-        }
-    }
-
-    /// Get the raw Ruby value directly
-    ///
-    /// This preserves object identity for singletons, allowing mutations
-    /// to persist across requests.
-    pub fn get_value(&self, ruby: &Ruby) -> Value {
-        self.value.get_inner_with(ruby)
-    }
-
-    /// Convert the wrapped Ruby value to JSON
-    ///
-    /// This is called fresh each time to capture any mutations to the object.
-    /// For singletons, this means we see updated counter values, etc.
-    pub fn to_json(&self, ruby: &Ruby) -> Result<JsonValue, Error> {
-        let value = self.value.get_inner_with(ruby);
-        ruby_value_to_json(ruby, value)
-    }
-}
-
-unsafe impl Send for RubyValueWrapper {}
-unsafe impl Sync for RubyValueWrapper {}
-
-/// Convert Ruby Value to serde_json::Value
-fn ruby_value_to_json(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
-    if value.is_nil() {
-        return Ok(JsonValue::Null);
-    }
-
-    let json_module: Value = ruby
-        .class_object()
-        .const_get("JSON")
-        .map_err(|_| Error::new(ruby.exception_runtime_error(), "JSON module not available"))?;
-
-    let json_string: String = json_module.funcall("generate", (value,))?;
-    serde_json::from_str(&json_string).map_err(|err| {
-        Error::new(
-            ruby.exception_runtime_error(),
-            format!("Failed to convert Ruby value to JSON: {err}"),
-        )
-    })
-}
-
-/// Convert serde_json::Value to Ruby Value
-pub fn json_to_ruby(ruby: &Ruby, value: &JsonValue) -> Result<Value, Error> {
-    match value {
-        JsonValue::Null => Ok(ruby.qnil().as_value()),
-        JsonValue::Bool(b) => Ok(if *b {
-            ruby.qtrue().as_value()
-        } else {
-            ruby.qfalse().as_value()
-        }),
-        JsonValue::Number(num) => {
-            if let Some(i) = num.as_i64() {
-                Ok(ruby.integer_from_i64(i).as_value())
-            } else if let Some(f) = num.as_f64() {
-                Ok(ruby.float_from_f64(f).as_value())
-            } else {
-                Ok(ruby.qnil().as_value())
-            }
-        }
-        JsonValue::String(str_val) => Ok(ruby.str_new(str_val).as_value()),
-        JsonValue::Array(items) => {
-            let array = ruby.ary_new();
-            for item in items {
-                array.push(json_to_ruby(ruby, item)?)?;
-            }
-            Ok(array.as_value())
-        }
-        JsonValue::Object(map) => {
-            let hash = ruby.hash_new();
-            for (key, item) in map {
-                hash.aset(ruby.str_new(key), json_to_ruby(ruby, item)?)?;
-            }
-            Ok(hash.as_value())
-        }
-    }
-}
-
-/// Helper to extract keyword arguments from Ruby options hash
-pub fn extract_di_options(ruby: &Ruby, options: Value) -> Result<(Vec<String>, bool, bool), Error> {
-    if options.is_nil() {
-        return Ok((Vec::new(), false, true));
-    }
-
-    let hash = RHash::try_convert(options)?;
-
-    let depends_on = if let Some(deps_value) = get_kw(ruby, hash, "depends_on") {
-        if deps_value.is_nil() {
-            Vec::new()
-        } else {
-            Vec::<String>::try_convert(deps_value)?
-        }
-    } else {
-        Vec::new()
-    };
-
-    let singleton = if let Some(singleton_value) = get_kw(ruby, hash, "singleton") {
-        bool::try_convert(singleton_value).unwrap_or(false)
-    } else {
-        false
-    };
-
-    let cacheable = if let Some(cacheable_value) = get_kw(ruby, hash, "cacheable") {
-        bool::try_convert(cacheable_value).unwrap_or(true)
-    } else {
-        true
-    };
-
-    Ok((depends_on, singleton, cacheable))
-}
-
-/// Get keyword argument from Ruby hash (tries both symbol and string keys)
-fn get_kw(ruby: &Ruby, hash: RHash, name: &str) -> Option<Value> {
-    let sym = ruby.intern(name);
-    hash.get(sym).or_else(|| hash.get(name))
-}