spikard 0.3.6 → 0.5.0

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

@@ -33,6 +33,7 @@ impl RubyLifecycleHook {
     }
 
     /// Mark Ruby values for GC
+    #[allow(dead_code)]
     pub fn mark(&self, marker: &Marker) {
         if let Ok(ruby) = magnus::Ruby::get() {
             marker.mark(self.func.get_inner_with(&ruby));

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

@@ -0,0 +1,5 @@
+//! Route metadata extraction and building from Ruby definitions.
+
+pub mod route_extraction;
+
+pub use route_extraction::{build_route_metadata, json_to_ruby, ruby_value_to_json};

data/vendor/crates/spikard-rb/src/metadata/route_extraction.rs

@@ -0,0 +1,447 @@
+//! Route metadata extraction and building from Ruby objects.
+//!
+//! This module handles converting Ruby route definitions into structured
+//! RouteMetadata that can be used by the Rust HTTP server.
+
+use magnus::prelude::*;
+use magnus::{Error, RArray, RHash, RString, Ruby, TryConvert, Value, r_hash::ForEach};
+use serde_json::{Map as JsonMap, Value as JsonValue};
+use spikard_http::{Route, RouteMetadata, SchemaRegistry};
+
+/// Build route metadata from Ruby parameters
+#[allow(clippy::too_many_arguments)]
+pub fn build_route_metadata(
+    ruby: &Ruby,
+    method: String,
+    path: String,
+    handler_name: Option<String>,
+    request_schema_value: Value,
+    response_schema_value: Value,
+    parameter_schema_value: Value,
+    file_params_value: Value,
+    is_async: bool,
+    cors_value: Value,
+    body_param_name: Option<String>,
+    jsonrpc_method_value: Value,
+    handler_value: Value,
+) -> Result<Value, Error> {
+    let normalized_path = normalize_path_for_route(&path);
+    let final_handler_name = handler_name.unwrap_or_else(|| default_handler_name(&method, &normalized_path));
+
+    let json_module = ruby
+        .class_object()
+        .const_get("JSON")
+        .map_err(|_| Error::new(ruby.exception_runtime_error(), "JSON module not available"))?;
+
+    let request_schema = if request_schema_value.is_nil() {
+        None
+    } else {
+        Some(ruby_value_to_json(ruby, json_module, request_schema_value)?)
+    };
+    let response_schema = if response_schema_value.is_nil() {
+        None
+    } else {
+        Some(ruby_value_to_json(ruby, json_module, response_schema_value)?)
+    };
+    let parameter_schema = if parameter_schema_value.is_nil() {
+        None
+    } else {
+        Some(ruby_value_to_json(ruby, json_module, parameter_schema_value)?)
+    };
+    let file_params = if file_params_value.is_nil() {
+        None
+    } else {
+        Some(ruby_value_to_json(ruby, json_module, file_params_value)?)
+    };
+
+    let cors = parse_cors_config(ruby, cors_value)?;
+    let handler_dependencies = extract_handler_dependencies_from_ruby(ruby, handler_value)?;
+
+    #[cfg(feature = "di")]
+    let handler_deps_option = if handler_dependencies.is_empty() {
+        None
+    } else {
+        Some(handler_dependencies.clone())
+    };
+
+    let jsonrpc_method = if jsonrpc_method_value.is_nil() {
+        None
+    } else {
+        Some(ruby_value_to_json(ruby, json_module, jsonrpc_method_value)?)
+    };
+
+    let mut metadata = RouteMetadata {
+        method,
+        path: normalized_path,
+        handler_name: final_handler_name,
+        request_schema,
+        response_schema,
+        parameter_schema,
+        file_params,
+        is_async,
+        cors,
+        body_param_name,
+        #[cfg(feature = "di")]
+        handler_dependencies: handler_deps_option,
+        jsonrpc_method,
+    };
+
+    let registry = SchemaRegistry::new();
+    let route = Route::from_metadata(metadata.clone(), &registry).map_err(|err| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to build route metadata: {err}"),
+        )
+    })?;
+
+    if let Some(validator) = route.parameter_validator.as_ref() {
+        metadata.parameter_schema = Some(validator.schema().clone());
+    }
+
+    route_metadata_to_ruby(ruby, &metadata)
+}
+
+/// Convert a RouteMetadata to a Ruby hash
+pub fn route_metadata_to_ruby(ruby: &Ruby, metadata: &RouteMetadata) -> Result<Value, Error> {
+    let hash = ruby.hash_new();
+
+    hash.aset(ruby.to_symbol("method"), ruby.str_new(&metadata.method))?;
+    hash.aset(ruby.to_symbol("path"), ruby.str_new(&metadata.path))?;
+    hash.aset(ruby.to_symbol("handler_name"), ruby.str_new(&metadata.handler_name))?;
+    let is_async_val: Value = if metadata.is_async {
+        ruby.qtrue().as_value()
+    } else {
+        ruby.qfalse().as_value()
+    };
+    hash.aset(ruby.to_symbol("is_async"), is_async_val)?;
+
+    hash.aset(
+        ruby.to_symbol("request_schema"),
+        option_json_to_ruby(ruby, &metadata.request_schema)?,
+    )?;
+    hash.aset(
+        ruby.to_symbol("response_schema"),
+        option_json_to_ruby(ruby, &metadata.response_schema)?,
+    )?;
+    hash.aset(
+        ruby.to_symbol("parameter_schema"),
+        option_json_to_ruby(ruby, &metadata.parameter_schema)?,
+    )?;
+    hash.aset(
+        ruby.to_symbol("file_params"),
+        option_json_to_ruby(ruby, &metadata.file_params)?,
+    )?;
+    hash.aset(
+        ruby.to_symbol("body_param_name"),
+        metadata
+            .body_param_name
+            .as_ref()
+            .map(|s| ruby.str_new(s).as_value())
+            .unwrap_or_else(|| ruby.qnil().as_value()),
+    )?;
+
+    hash.aset(ruby.to_symbol("cors"), cors_to_ruby(ruby, &metadata.cors)?)?;
+
+    #[cfg(feature = "di")]
+    {
+        if let Some(deps) = &metadata.handler_dependencies {
+            let array = ruby.ary_new();
+            for dep in deps {
+                array.push(ruby.str_new(dep))?;
+            }
+            hash.aset(ruby.to_symbol("handler_dependencies"), array)?;
+        } else {
+            hash.aset(ruby.to_symbol("handler_dependencies"), ruby.qnil())?;
+        }
+    }
+
+    hash.aset(
+        ruby.to_symbol("jsonrpc_method"),
+        option_json_to_ruby(ruby, &metadata.jsonrpc_method)?,
+    )?;
+
+    Ok(hash.as_value())
+}
+
+/// Normalize path for routes (convert :param to {param})
+pub fn normalize_path_for_route(path: &str) -> String {
+    let has_trailing_slash = path.ends_with('/');
+    let segments = path.split('/').map(|segment| {
+        if let Some(stripped) = segment.strip_prefix(':') {
+            format!("{{{}}}", stripped)
+        } else {
+            segment.to_string()
+        }
+    });
+
+    let normalized = segments.collect::<Vec<_>>().join("/");
+    if has_trailing_slash && !normalized.ends_with('/') {
+        format!("{normalized}/")
+    } else {
+        normalized
+    }
+}
+
+/// Generate default handler name from method and path
+pub fn default_handler_name(method: &str, path: &str) -> String {
+    let normalized_path: String = path
+        .chars()
+        .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+        .collect();
+    let trimmed = normalized_path.trim_matches('_');
+    let final_segment = if trimmed.is_empty() { "root" } else { trimmed };
+    format!("{}_{}", method.to_ascii_lowercase(), final_segment)
+}
+
+/// Extract handler dependencies from a Ruby handler callable
+pub fn extract_handler_dependencies_from_ruby(_ruby: &Ruby, handler_value: Value) -> Result<Vec<String>, Error> {
+    if handler_value.is_nil() {
+        return Ok(Vec::new());
+    }
+
+    let params_value: Value = handler_value.funcall("parameters", ())?;
+    let params = RArray::try_convert(params_value)?;
+
+    let mut dependencies = Vec::new();
+    for i in 0..params.len() {
+        let entry: Value = params.entry(i as isize)?;
+        if let Some(pair) = RArray::from_value(entry) {
+            if pair.len() < 2 {
+                continue;
+            }
+
+            let kind_val: Value = pair.entry(0)?;
+            let name_val: Value = pair.entry(1)?;
+
+            let kind_symbol: magnus::Symbol = magnus::Symbol::try_convert(kind_val)?;
+            let kind_name = kind_symbol.name().unwrap_or_default();
+
+            if kind_name == "key" || kind_name == "keyreq" {
+                if let Ok(sym) = magnus::Symbol::try_convert(name_val) {
+                    if let Ok(name) = sym.name() {
+                        dependencies.push(name.to_string());
+                    }
+                } else {
+                    dependencies.push(String::try_convert(name_val)?);
+                }
+            }
+        }
+    }
+
+    Ok(dependencies)
+}
+
+/// Parse CORS configuration from Ruby value
+pub fn parse_cors_config(ruby: &Ruby, value: Value) -> Result<Option<spikard_http::CorsConfig>, Error> {
+    if value.is_nil() {
+        return Ok(None);
+    }
+
+    let hash = RHash::try_convert(value)?;
+    let lookup = |key: &str| -> Option<Value> {
+        hash.get(ruby.to_symbol(key))
+            .or_else(|| hash.get(ruby.str_new(key)))
+    };
+
+    let allowed_origins = lookup("allowed_origins")
+        .and_then(|v| Vec::<String>::try_convert(v).ok())
+        .unwrap_or_default();
+    let allowed_methods = lookup("allowed_methods")
+        .and_then(|v| Vec::<String>::try_convert(v).ok())
+        .unwrap_or_default();
+    let allowed_headers = lookup("allowed_headers")
+        .and_then(|v| Vec::<String>::try_convert(v).ok())
+        .unwrap_or_default();
+    let expose_headers = lookup("expose_headers")
+        .and_then(|v| Vec::<String>::try_convert(v).ok());
+    let max_age = lookup("max_age")
+        .and_then(|v| i64::try_convert(v).ok())
+        .map(|v| v as u32);
+    let allow_credentials = lookup("allow_credentials")
+        .and_then(|v| bool::try_convert(v).ok());
+
+    Ok(Some(spikard_http::CorsConfig {
+        allowed_origins,
+        allowed_methods,
+        allowed_headers,
+        expose_headers,
+        max_age,
+        allow_credentials,
+    }))
+}
+
+/// Convert an optional JSON value to Ruby
+pub fn option_json_to_ruby(ruby: &Ruby, value: &Option<JsonValue>) -> Result<Value, Error> {
+    if let Some(json) = value {
+        json_to_ruby(ruby, json)
+    } else {
+        Ok(ruby.qnil().as_value())
+    }
+}
+
+/// Convert CORS config to Ruby hash
+pub fn cors_to_ruby(ruby: &Ruby, cors: &Option<spikard_http::CorsConfig>) -> Result<Value, Error> {
+    if let Some(cors_config) = cors {
+        let hash = ruby.hash_new();
+        let origins = cors_config
+            .allowed_origins
+            .iter()
+            .map(|s| JsonValue::String(s.clone()))
+            .collect();
+        hash.aset(
+            ruby.to_symbol("allowed_origins"),
+            json_to_ruby(ruby, &JsonValue::Array(origins))?,
+        )?;
+        let methods = cors_config
+            .allowed_methods
+            .iter()
+            .map(|s| JsonValue::String(s.clone()))
+            .collect();
+        hash.aset(
+            ruby.to_symbol("allowed_methods"),
+            json_to_ruby(ruby, &JsonValue::Array(methods))?,
+        )?;
+        let headers = cors_config
+            .allowed_headers
+            .iter()
+            .map(|s| JsonValue::String(s.clone()))
+            .collect();
+        hash.aset(
+            ruby.to_symbol("allowed_headers"),
+            json_to_ruby(ruby, &JsonValue::Array(headers))?,
+        )?;
+        hash.aset(
+            ruby.to_symbol("expose_headers"),
+            if let Some(expose_headers) = &cors_config.expose_headers {
+                let expose = expose_headers.iter().map(|s| JsonValue::String(s.clone())).collect();
+                json_to_ruby(ruby, &JsonValue::Array(expose))?
+            } else {
+                ruby.qnil().as_value()
+            },
+        )?;
+        hash.aset(
+            ruby.to_symbol("max_age"),
+            if let Some(max_age) = cors_config.max_age {
+                ruby.integer_from_i64(max_age as i64).as_value()
+            } else {
+                ruby.qnil().as_value()
+            },
+        )?;
+        hash.aset(
+            ruby.to_symbol("allow_credentials"),
+            if let Some(allow_creds) = cors_config.allow_credentials {
+                if allow_creds {
+                    ruby.qtrue().as_value()
+                } else {
+                    ruby.qfalse().as_value()
+                }
+            } else {
+                ruby.qnil().as_value()
+            },
+        )?;
+        Ok(hash.as_value())
+    } else {
+        Ok(ruby.qnil().as_value())
+    }
+}
+
+/// Convert Ruby value to JSON
+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 value.is_kind_of(ruby.class_true_class()) {
+        return Ok(JsonValue::Bool(true));
+    }
+
+    if value.is_kind_of(ruby.class_false_class()) {
+        return Ok(JsonValue::Bool(false));
+    }
+
+    if value.is_kind_of(ruby.class_float()) {
+        let float_val = f64::try_convert(value)?;
+        if let Some(num) = serde_json::Number::from_f64(float_val) {
+            return Ok(JsonValue::Number(num));
+        }
+    }
+
+    if value.is_kind_of(ruby.class_integer()) {
+        if let Ok(int_val) = i64::try_convert(value) {
+            return Ok(JsonValue::Number(int_val.into()));
+        }
+        if let Ok(int_val) = u64::try_convert(value) {
+            return Ok(JsonValue::Number(int_val.into()));
+        }
+    }
+
+    if let Ok(str_val) = RString::try_convert(value) {
+        let slice = str_val.to_string()?;
+        return Ok(JsonValue::String(slice));
+    }
+
+    if let Some(array) = RArray::from_value(value) {
+        let mut items = Vec::with_capacity(array.len());
+        let slice = unsafe { array.as_slice() };
+        for elem in slice {
+            items.push(ruby_value_to_json(ruby, _json_module, *elem)?);
+        }
+        return Ok(JsonValue::Array(items));
+    }
+
+    if let Some(hash) = RHash::from_value(value) {
+        let mut map = JsonMap::new();
+        hash.foreach(|key: Value, val: Value| -> Result<ForEach, Error> {
+            let key_str: String = if let Ok(sym) = magnus::Symbol::try_convert(key) {
+                sym.name().map(|c| c.to_string()).unwrap_or_default()
+            } else {
+                String::try_convert(key)?
+            };
+            let json_val = ruby_value_to_json(ruby, _json_module, val)?;
+            map.insert(key_str, json_val);
+            Ok(ForEach::Continue)
+        })?;
+        return Ok(JsonValue::Object(map));
+    }
+
+    Err(Error::new(
+        ruby.exception_arg_error(),
+        "Unsupported Ruby value type for JSON conversion",
+    ))
+}
+
+/// Convert JSON 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())
+        }
+    }
+}

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

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