spikard 0.3.6 → 0.5.0

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

@@ -4,17 +4,18 @@
 //! and implements Spikard's `Handler` trait for async request processing.
 
 #![allow(dead_code)]
+#![deny(clippy::unwrap_used)]
 
 use axum::body::Body;
 use axum::http::{HeaderName, HeaderValue, Request, StatusCode};
 use magnus::prelude::*;
+use magnus::value::LazyId;
 use magnus::value::{InnerValue, Opaque};
 use magnus::{Error, RHash, RString, Ruby, TryConvert, Value, gc::Marker};
-use serde_json::{Map as JsonMap, Value as JsonValue};
-use spikard_core::errors::StructuredError;
-use spikard_http::ParameterValidator;
+use serde_json::Value as JsonValue;
+use spikard_bindings_shared::ErrorResponseBuilder;
+use spikard_core::problem::ProblemDetails;
 use spikard_http::SchemaValidator;
-use spikard_http::problem::ProblemDetails;
 use spikard_http::{Handler, HandlerResponse, HandlerResult, RequestData};
 use std::collections::HashMap;
 use std::panic::AssertUnwindSafe;
@@ -25,6 +26,17 @@ use crate::conversion::{
     json_to_ruby, json_to_ruby_with_uploads, map_to_ruby_hash, multimap_to_ruby_hash, ruby_value_to_json,
 };
 
+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");
+
 /// Response payload with status, headers, and body data.
 pub struct HandlerResponsePayload {
     pub status: u16,
@@ -51,8 +63,8 @@ impl StreamingResponsePayload {
     pub fn into_response(self) -> Result<HandlerResponse, Error> {
         let ruby = Ruby::get().map_err(|_| {
             Error::new(
-                Ruby::get().unwrap().exception_runtime_error(),
-                "Ruby VM unavailable while building streaming response",
+                magnus::exception::runtime_error(),
+                "Ruby VM became unavailable during streaming response construction",
             )
         })?;
 
@@ -127,10 +139,10 @@ pub struct RubyHandlerInner {
     pub handler_name: String,
     pub method: String,
     pub path: String,
+    method_value: Opaque<Value>,
+    path_value: Opaque<Value>,
     pub json_module: Opaque<Value>,
-    pub request_validator: Option<Arc<SchemaValidator>>,
     pub response_validator: Option<Arc<SchemaValidator>>,
-    pub parameter_validator: Option<ParameterValidator>,
     pub upload_file_class: Option<Opaque<Value>>,
 }
 
@@ -143,17 +155,33 @@ pub struct RubyHandler {
 impl RubyHandler {
     /// Create a new RubyHandler from a route and handler Proc.
     pub fn new(route: &spikard_http::Route, handler_value: Value, json_module: Value) -> Result<Self, Error> {
-        let upload_file_class = lookup_upload_file_class()?;
+        let upload_file_class = if route.file_params.is_some() {
+            lookup_upload_file_class()?
+        } else {
+            None
+        };
+        let method = route.method.as_str().to_string();
+        let path = route.path.clone();
+
+        let Ok(ruby) = Ruby::get() else {
+            return Err(Error::new(
+                magnus::exception::runtime_error(),
+                "Ruby VM unavailable while creating handler",
+            ));
+        };
+        let method_value = Opaque::from(ruby.str_new(&method).as_value());
+        let path_value = Opaque::from(ruby.str_new(&path).as_value());
+
         Ok(Self {
             inner: Arc::new(RubyHandlerInner {
                 handler_proc: Opaque::from(handler_value),
                 handler_name: route.handler_name.clone(),
-                method: route.method.as_str().to_string(),
-                path: route.path.clone(),
+                method,
+                path,
+                method_value,
+                path_value,
                 json_module: Opaque::from(json_module),
-                request_validator: route.request_validator.clone(),
                 response_validator: route.response_validator.clone(),
-                parameter_validator: route.parameter_validator.clone(),
                 upload_file_class,
             }),
         })
@@ -171,17 +199,30 @@ impl RubyHandler {
         json_module: Value,
         route: &spikard_http::Route,
     ) -> Result<Self, Error> {
-        let upload_file_class = lookup_upload_file_class()?;
+        let upload_file_class = if route.file_params.is_some() {
+            lookup_upload_file_class()?
+        } else {
+            None
+        };
+        let Ok(ruby) = Ruby::get() else {
+            return Err(Error::new(
+                magnus::exception::runtime_error(),
+                "Ruby VM unavailable while creating handler",
+            ));
+        };
+        let method_value = Opaque::from(ruby.str_new(&method).as_value());
+        let path_value = Opaque::from(ruby.str_new(&path).as_value());
+
         Ok(Self {
             inner: Arc::new(RubyHandlerInner {
                 handler_proc: Opaque::from(handler_value),
                 handler_name,
                 method,
                 path,
+                method_value,
+                path_value,
                 json_module: Opaque::from(json_module),
-                request_validator: route.request_validator.clone(),
                 response_validator: route.response_validator.clone(),
-                parameter_validator: route.parameter_validator.clone(),
                 upload_file_class,
             }),
         })
@@ -193,16 +234,17 @@ impl RubyHandler {
         if let Ok(ruby) = Ruby::get() {
             let proc_val = self.inner.handler_proc.get_inner_with(&ruby);
             marker.mark(proc_val);
+            marker.mark(self.inner.method_value.get_inner_with(&ruby));
+            marker.mark(self.inner.path_value.get_inner_with(&ruby));
         }
     }
 
     /// Handle a request synchronously.
     pub fn handle(&self, request_data: RequestData) -> HandlerResult {
-        let cloned = request_data.clone();
-        let result = std::panic::catch_unwind(AssertUnwindSafe(|| self.handle_inner(cloned)));
+        let result = std::panic::catch_unwind(AssertUnwindSafe(|| self.handle_inner(request_data)));
         match result {
             Ok(res) => res,
-            Err(_) => Err(structured_error(
+            Err(_) => Err(ErrorResponseBuilder::structured_error(
                 StatusCode::INTERNAL_SERVER_ERROR,
                 "panic",
                 "Unexpected panic while executing Ruby handler",
@@ -211,33 +253,10 @@ impl RubyHandler {
     }
 
     fn handle_inner(&self, request_data: RequestData) -> HandlerResult {
-        if let Some(validator) = &self.inner.request_validator
-            && let Err(errors) = validator.validate(&request_data.body)
-        {
-            let problem = ProblemDetails::from_validation_error(&errors);
-            return Err(validation_error_response(&problem));
-        }
-
-        let validated_params = if let Some(validator) = &self.inner.parameter_validator {
-            match validator.validate_and_extract(
-                &request_data.query_params,
-                request_data.raw_query_params.as_ref(),
-                request_data.path_params.as_ref(),
-                request_data.headers.as_ref(),
-                request_data.cookies.as_ref(),
-            ) {
-                Ok(value) => Some(value),
-                Err(errors) => {
-                    let problem = ProblemDetails::from_validation_error(&errors);
-                    return Err(validation_error_response(&problem));
-                }
-            }
-        } else {
-            None
-        };
+        let validated_params = request_data.validated_params.clone();
 
         let ruby = Ruby::get().map_err(|_| {
-            structured_error(
+            ErrorResponseBuilder::structured_error(
                 StatusCode::INTERNAL_SERVER_ERROR,
                 "ruby_vm_unavailable",
                 "Ruby VM unavailable while invoking handler",
@@ -252,7 +271,7 @@ impl RubyHandler {
         let response_value = match handler_result {
             Ok(value) => value,
             Err(err) => {
-                return Err(structured_error(
+                return Err(ErrorResponseBuilder::structured_error(
                     StatusCode::INTERNAL_SERVER_ERROR,
                     "handler_failed",
                     format!("Handler '{}' failed: {}", self.inner.handler_name, err),
@@ -261,7 +280,7 @@ impl RubyHandler {
         };
 
         let handler_result = interpret_handler_response(&ruby, &self.inner, response_value).map_err(|err| {
-            structured_error(
+            ErrorResponseBuilder::structured_error(
                 StatusCode::INTERNAL_SERVER_ERROR,
                 "response_interpret_error",
                 format!(
@@ -274,7 +293,7 @@ impl RubyHandler {
         let payload = match handler_result {
             RubyHandlerResult::Streaming(streaming) => {
                 let response = streaming.into_response().map_err(|err| {
-                    structured_error(
+                    ErrorResponseBuilder::structured_error(
                         StatusCode::INTERNAL_SERVER_ERROR,
                         "streaming_response_error",
                         format!("Failed to build streaming response: {}", err),
@@ -291,7 +310,7 @@ impl RubyHandler {
                 None => match try_parse_raw_body(&payload.raw_body) {
                     Ok(parsed) => parsed,
                     Err(err) => {
-                        return Err(structured_error(
+                        return Err(ErrorResponseBuilder::structured_error(
                             StatusCode::INTERNAL_SERVER_ERROR,
                             "response_body_decode_error",
                             err,
@@ -304,11 +323,11 @@ impl RubyHandler {
                 Some(json_body) => {
                     if let Err(errors) = validator.validate(&json_body) {
                         let problem = ProblemDetails::from_validation_error(&errors);
-                        return Err(validation_error_response(&problem));
+                        return Err(ErrorResponseBuilder::problem_details_response(&problem));
                     }
                 }
                 None => {
-                    return Err(structured_error(
+                    return Err(ErrorResponseBuilder::structured_error(
                         StatusCode::INTERNAL_SERVER_ERROR,
                         "response_validation_failed",
                         "Response validator requires JSON body but handler returned raw bytes",
@@ -387,24 +406,6 @@ impl Handler for RubyHandler {
     }
 }
 
-fn structured_error(status: StatusCode, code: &str, message: impl Into<String>) -> (StatusCode, String) {
-    let payload = StructuredError::simple(code.to_string(), message.into());
-    let body = serde_json::to_string(&payload)
-        .unwrap_or_else(|_| r#"{"error":"internal_error","code":"internal_error","details":{}}"#.to_string());
-    (status, body)
-}
-
-fn validation_error_response(problem: &ProblemDetails) -> (StatusCode, String) {
-    let payload = StructuredError::new(
-        "validation_error".to_string(),
-        problem.title.clone(),
-        serde_json::to_value(problem).unwrap_or_else(|_| serde_json::json!({})),
-    );
-    let body = serde_json::to_string(&payload)
-        .unwrap_or_else(|_| r#"{"error":"validation_error","code":"validation_error","details":{}}"#.to_string());
-    (problem.status_code(), body)
-}
-
 fn try_parse_raw_body(raw_body: &Option<Vec<u8>>) -> Result<Option<JsonValue>, String> {
     let Some(bytes) = raw_body else {
         return Ok(None);
@@ -435,69 +436,70 @@ fn build_ruby_request(
     request_data: &RequestData,
     validated_params: Option<&JsonValue>,
 ) -> Result<Value, Error> {
-    let hash = ruby.hash_new();
+    let hash = ruby.hash_new_capa(9);
 
-    hash.aset(ruby.intern("method"), ruby.str_new(&handler.method))?;
-    hash.aset(ruby.intern("path"), ruby.str_new(&handler.path))?;
+    hash.aset(*KEY_METHOD, handler.method_value.get_inner_with(ruby))?;
+    hash.aset(*KEY_PATH, handler.path_value.get_inner_with(ruby))?;
 
     let path_params = map_to_ruby_hash(ruby, request_data.path_params.as_ref())?;
-    hash.aset(ruby.intern("path_params"), path_params)?;
+    hash.aset(*KEY_PATH_PARAMS, path_params)?;
 
     let query_value = json_to_ruby(ruby, &request_data.query_params)?;
-    hash.aset(ruby.intern("query"), query_value)?;
+    hash.aset(*KEY_QUERY, query_value)?;
 
     let raw_query = multimap_to_ruby_hash(ruby, request_data.raw_query_params.as_ref())?;
-    hash.aset(ruby.intern("raw_query"), raw_query)?;
+    hash.aset(*KEY_RAW_QUERY, raw_query)?;
 
     let headers = map_to_ruby_hash(ruby, request_data.headers.as_ref())?;
-    hash.aset(ruby.intern("headers"), headers)?;
+    hash.aset(*KEY_HEADERS, headers)?;
 
     let cookies = map_to_ruby_hash(ruby, request_data.cookies.as_ref())?;
-    hash.aset(ruby.intern("cookies"), cookies)?;
+    hash.aset(*KEY_COOKIES, cookies)?;
 
     let upload_class_value = handler.upload_file_class.as_ref().map(|cls| cls.get_inner_with(ruby));
     let body_value = json_to_ruby_with_uploads(ruby, &request_data.body, upload_class_value.as_ref())?;
-    hash.aset(ruby.intern("body"), body_value)?;
+    hash.aset(*KEY_BODY, body_value)?;
     if let Some(raw) = &request_data.raw_body {
         let raw_str = ruby.str_from_slice(raw);
-        hash.aset(ruby.intern("raw_body"), raw_str)?;
+        hash.aset(*KEY_RAW_BODY, raw_str)?;
     } else {
-        hash.aset(ruby.intern("raw_body"), ruby.qnil())?;
+        hash.aset(*KEY_RAW_BODY, ruby.qnil())?;
     }
 
     let params_value = if let Some(validated) = validated_params {
         json_to_ruby(ruby, validated)?
     } else {
-        build_default_params(ruby, request_data)?
+        build_default_params_from_converted(ruby, path_params, query_value, headers, cookies)?
     };
-    hash.aset(ruby.intern("params"), params_value)?;
+    hash.aset(*KEY_PARAMS, params_value)?;
 
     Ok(hash.as_value())
 }
 
-/// Build default params from request data path/query/headers/cookies.
-fn build_default_params(ruby: &Ruby, request_data: &RequestData) -> Result<Value, Error> {
-    let mut map = JsonMap::new();
+/// Build default params from already converted Ruby values, avoiding double conversion.
+fn build_default_params_from_converted(
+    ruby: &Ruby,
+    path_params: Value,
+    query: Value,
+    headers: Value,
+    cookies: Value,
+) -> Result<Value, Error> {
+    let params = ruby.hash_new();
 
-    for (key, value) in request_data.path_params.as_ref() {
-        map.insert(key.clone(), JsonValue::String(value.clone()));
+    if let Some(hash) = RHash::from_value(path_params) {
+        let _: Value = params.funcall("merge!", (hash,))?;
     }
-
-    if let JsonValue::Object(obj) = &request_data.query_params {
-        for (key, value) in obj {
-            map.insert(key.clone(), value.clone());
-        }
+    if let Some(hash) = RHash::from_value(query) {
+        let _: Value = params.funcall("merge!", (hash,))?;
     }
-
-    for (key, value) in request_data.headers.as_ref() {
-        map.insert(key.clone(), JsonValue::String(value.clone()));
+    if let Some(hash) = RHash::from_value(headers) {
+        let _: Value = params.funcall("merge!", (hash,))?;
     }
-
-    for (key, value) in request_data.cookies.as_ref() {
-        map.insert(key.clone(), JsonValue::String(value.clone()));
+    if let Some(hash) = RHash::from_value(cookies) {
+        let _: Value = params.funcall("merge!", (hash,))?;
     }
 
-    json_to_ruby(ruby, &JsonValue::Object(map))
+    Ok(params.as_value())
 }
 
 /// Interpret a Ruby handler response into our response types.
@@ -555,11 +557,6 @@ fn interpret_handler_response(
         let body = if content_value.is_nil() {
             None
         } else if let Ok(str_value) = RString::try_convert(content_value) {
-            // SAFETY: Magnus RString::as_slice() yields a valid byte slice for the
-            // lifetime of the RString value. We immediately call .to_vec() which copies
-            // the bytes into owned memory, so the result does not retain any references
-            // to the underlying RString. This is safe because the copy happens before
-            // the RString reference is released.
             let slice = unsafe { str_value.as_slice() };
             raw_body = Some(slice.to_vec());
             None
@@ -580,10 +577,6 @@ fn interpret_handler_response(
     }
 
     if let Ok(str_value) = RString::try_convert(value) {
-        // SAFETY: Magnus RString::as_slice() returns a valid byte slice that remains
-        // valid for the lifetime of the RString. We call .to_vec() to copy the bytes
-        // into owned storage, ensuring the returned HandlerResponsePayload does not
-        // hold any references back to the RString. This copy-then-own pattern is safe.
         let slice = unsafe { str_value.as_slice() };
         return Ok(RubyHandlerResult::Payload(HandlerResponsePayload {
             status: 200,

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

@@ -0,0 +1,3 @@
+//! Integration-level utilities for testing and dependency injection.
+
+pub use crate::di::build_dependency_container;