spikard 0.3.4 → 0.3.6

data/vendor/spikard-rb/src/sse.rs

@@ -1,231 +0,0 @@
-//! Ruby SSE producer bindings
-//!
-//! This module provides the bridge between Ruby blocks/procs and Rust's SSE system.
-//! Uses magnus to safely call Ruby code from Rust async tasks.
-
-use magnus::{RHash, Value, prelude::*, value::Opaque};
-use serde_json::Value as JsonValue;
-use spikard_http::{SseEvent, SseEventProducer};
-use tracing::{debug, error};
-
-/// Ruby implementation of SseEventProducer
-pub struct RubySseEventProducer {
-    /// Producer name for debugging
-    name: String,
-    /// Ruby proc/callable for next_event (Opaque for Send safety)
-    next_event_proc: Opaque<Value>,
-    /// Ruby proc/callable for on_connect (Opaque for Send safety)
-    on_connect_proc: Option<Opaque<Value>>,
-    /// Ruby proc/callable for on_disconnect (Opaque for Send safety)
-    on_disconnect_proc: Option<Opaque<Value>>,
-}
-
-impl RubySseEventProducer {
-    /// Create a new Ruby SSE event producer
-    #[allow(dead_code)]
-    pub fn new(
-        name: String,
-        next_event_proc: Value,
-        on_connect_proc: Option<Value>,
-        on_disconnect_proc: Option<Value>,
-    ) -> Self {
-        Self {
-            name,
-            next_event_proc: next_event_proc.into(),
-            on_connect_proc: on_connect_proc.map(|v| v.into()),
-            on_disconnect_proc: on_disconnect_proc.map(|v| v.into()),
-        }
-    }
-
-    /// Convert Ruby value to JSON
-    fn ruby_to_json(ruby: &magnus::Ruby, value: Value) -> Result<JsonValue, String> {
-        if value.is_nil() {
-            return Ok(JsonValue::Null);
-        }
-
-        let json_module: Value = ruby
-            .class_object()
-            .const_get("JSON")
-            .map_err(|e| format!("JSON module not available: {}", e))?;
-
-        let json_str: String = json_module
-            .funcall("generate", (value,))
-            .map_err(|e| format!("Failed to generate JSON: {}", e))?;
-
-        serde_json::from_str(&json_str).map_err(|e| format!("Failed to parse JSON: {}", e))
-    }
-}
-
-impl SseEventProducer for RubySseEventProducer {
-    async fn next_event(&self) -> Option<SseEvent> {
-        debug!("Ruby SSE producer '{}': next_event", self.name);
-
-        match magnus::Ruby::get()
-            .map_err(|e| format!("Failed to get Ruby: {}", e))
-            .and_then(|ruby| {
-                debug!("Ruby SSE producer: acquired Ruby VM");
-
-                let proc_value = ruby.get_inner(self.next_event_proc);
-                let result: Value = proc_value
-                    .funcall("call", ())
-                    .map_err(|e| format!("Producer '{}' call failed: {}", self.name, e))?;
-
-                debug!("Ruby SSE producer: called next_event proc");
-
-                if result.is_nil() {
-                    debug!("Ruby SSE producer: received nil, ending stream");
-                    return Ok(None);
-                }
-
-                let result_hash = if let Some(hash) = RHash::from_value(result) {
-                    hash
-                } else {
-                    let hash_value: Value = result.funcall("to_h", ()).map_err(|e| {
-                        format!(
-                            "next_event must return a Hash/SseEvent convertible via to_h ({}): {}",
-                            unsafe { result.classname() },
-                            e
-                        )
-                    })?;
-                    RHash::from_value(hash_value).ok_or_else(|| {
-                        format!("next_event to_h must return a Hash, got {}", unsafe {
-                            hash_value.classname()
-                        })
-                    })?
-                };
-
-                let data_value = result_hash
-                    .get(ruby.to_symbol("data"))
-                    .ok_or_else(|| "next_event Hash must have :data key".to_string())?;
-
-                let data_json = Self::ruby_to_json(&ruby, data_value)?;
-
-                let event_type: Option<String> = result_hash
-                    .get(ruby.to_symbol("event_type"))
-                    .and_then(|v| if v.is_nil() { None } else { String::try_convert(v).ok() });
-
-                let id: Option<String> = result_hash
-                    .get(ruby.to_symbol("id"))
-                    .and_then(|v| if v.is_nil() { None } else { String::try_convert(v).ok() });
-
-                let retry: Option<u64> = result_hash
-                    .get(ruby.to_symbol("retry"))
-                    .and_then(|v| if v.is_nil() { None } else { u64::try_convert(v).ok() });
-
-                let mut event = if let Some(et) = event_type {
-                    SseEvent::with_type(et, data_json)
-                } else {
-                    SseEvent::new(data_json)
-                };
-
-                if let Some(id_str) = id {
-                    event = event.with_id(id_str);
-                }
-
-                if let Some(retry_ms) = retry {
-                    event = event.with_retry(retry_ms);
-                }
-
-                Ok(Some(event))
-            }) {
-            Ok(event) => event,
-            Err(e) => {
-                error!("Ruby error in next_event: {}", e);
-                None
-            }
-        }
-    }
-
-    async fn on_connect(&self) {
-        debug!("Ruby SSE producer '{}': on_connect", self.name);
-
-        if let Some(on_connect_proc) = self.on_connect_proc
-            && let Err(e) = magnus::Ruby::get()
-                .map_err(|e| format!("Failed to get Ruby: {}", e))
-                .and_then(|ruby| {
-                    debug!("Ruby SSE producer: on_connect acquired Ruby VM");
-                    let proc_value = ruby.get_inner(on_connect_proc);
-                    proc_value
-                        .funcall::<_, _, Value>("call", ())
-                        .map_err(|e| format!("on_connect '{}' call failed: {}", self.name, e))?;
-                    debug!("Ruby SSE producer: on_connect completed");
-                    Ok(())
-                })
-        {
-            error!("on_connect error: {}", e);
-        }
-    }
-
-    async fn on_disconnect(&self) {
-        debug!("Ruby SSE producer '{}': on_disconnect", self.name);
-
-        if let Some(on_disconnect_proc) = self.on_disconnect_proc
-            && let Err(e) = magnus::Ruby::get()
-                .map_err(|e| format!("Failed to get Ruby: {}", e))
-                .and_then(|ruby| {
-                    let proc_value = ruby.get_inner(on_disconnect_proc);
-                    proc_value
-                        .funcall::<_, _, Value>("call", ())
-                        .map_err(|e| format!("on_disconnect '{}' call failed: {}", self.name, e))?;
-                    debug!("Ruby SSE producer: on_disconnect completed");
-                    Ok(())
-                })
-        {
-            error!("on_disconnect error: {}", e);
-        }
-    }
-}
-
-unsafe impl Send for RubySseEventProducer {}
-unsafe impl Sync for RubySseEventProducer {}
-
-/// Create SseState from Ruby producer object
-///
-/// This function is designed to be called from Ruby to register SSE producers.
-#[allow(dead_code)]
-pub fn create_sse_state(
-    ruby: &magnus::Ruby,
-    producer_obj: Value,
-) -> Result<spikard_http::SseState<RubySseEventProducer>, magnus::Error> {
-    let next_event_proc: Value = producer_obj
-        .funcall("method", (ruby.to_symbol("next_event"),))
-        .map_err(|e| {
-            magnus::Error::new(
-                ruby.exception_arg_error(),
-                format!("next_event method not found: {}", e),
-            )
-        })?;
-
-    let on_connect_proc = producer_obj
-        .funcall::<_, _, Value>("method", (ruby.to_symbol("on_connect"),))
-        .ok();
-
-    let on_disconnect_proc = producer_obj
-        .funcall::<_, _, Value>("method", (ruby.to_symbol("on_disconnect"),))
-        .ok();
-
-    let event_schema = producer_obj
-        .funcall::<_, _, Value>("instance_variable_get", (ruby.to_symbol("@_event_schema"),))
-        .ok()
-        .and_then(|v| {
-            if v.is_nil() {
-                None
-            } else {
-                RubySseEventProducer::ruby_to_json(ruby, v).ok()
-            }
-        });
-
-    let ruby_producer = RubySseEventProducer::new(
-        "SseEventProducer".to_string(),
-        next_event_proc,
-        on_connect_proc,
-        on_disconnect_proc,
-    );
-
-    if event_schema.is_some() {
-        spikard_http::SseState::with_schema(ruby_producer, event_schema)
-            .map_err(|e| magnus::Error::new(ruby.exception_runtime_error(), e))
-    } else {
-        Ok(spikard_http::SseState::new(ruby_producer))
-    }
-}

data/vendor/spikard-rb/src/test_client.rs

@@ -1,404 +0,0 @@
-//! Native Ruby test client for HTTP testing.
-//!
-//! This module implements `NativeTestClient`, a wrapped Ruby class that provides
-//! HTTP testing capabilities against a Spikard server. It manages test servers
-//! for both HTTP and WebSocket/SSE transports.
-
-#![allow(dead_code)]
-
-use axum::http::Method;
-use axum_test::{TestServer, TestServerConfig, Transport};
-use bytes::Bytes;
-use cookie::Cookie;
-use magnus::prelude::*;
-use magnus::{Error, RHash, Ruby, Value, gc::Marker};
-use serde_json::Value as JsonValue;
-use spikard_http::testing::{
-    MultipartFilePart, SnapshotError, build_multipart_body, encode_urlencoded_body, snapshot_response,
-};
-use spikard_http::{Route, RouteMetadata};
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use crate::conversion::{parse_request_config, response_to_ruby};
-use crate::handler::RubyHandler;
-use crate::server::GLOBAL_RUNTIME;
-
-/// Request configuration built from Ruby options hash.
-pub struct RequestConfig {
-    pub query: Option<JsonValue>,
-    pub headers: HashMap<String, String>,
-    pub cookies: HashMap<String, String>,
-    pub body: Option<RequestBody>,
-}
-
-/// HTTP request body variants.
-pub enum RequestBody {
-    Json(JsonValue),
-    Form(JsonValue),
-    Raw(String),
-    Multipart {
-        form_data: Vec<(String, String)>,
-        files: Vec<MultipartFilePart>,
-    },
-}
-
-/// Snapshot of an HTTP response.
-pub struct TestResponseData {
-    pub status: u16,
-    pub headers: HashMap<String, String>,
-    pub body_text: Option<String>,
-}
-
-/// Error wrapper for native request failures.
-#[derive(Debug)]
-pub struct NativeRequestError(pub String);
-
-/// Inner client state containing the test servers and handlers.
-pub struct ClientInner {
-    pub http_server: Arc<TestServer>,
-    pub transport_server: Arc<TestServer>,
-    /// Keep Ruby handler closures alive for GC; accessed via the `mark` hook.
-    #[allow(dead_code)]
-    pub handlers: Vec<RubyHandler>,
-}
-
-/// Native Ruby TestClient wrapper for integration testing.
-///
-/// Wraps an optional `ClientInner` that holds the HTTP test servers
-/// and keeps handler references alive for Ruby's garbage collector.
-#[derive(Default)]
-#[magnus::wrap(class = "Spikard::Native::TestClient", free_immediately, mark)]
-pub struct NativeTestClient {
-    pub inner: RefCell<Option<ClientInner>>,
-}
-
-impl NativeTestClient {
-    /// Initialize the test client with routes, handlers, and server config.
-    ///
-    /// # Arguments
-    ///
-    /// * `ruby` - Ruby VM reference
-    /// * `this` - The wrapped NativeTestClient instance
-    /// * `routes_json` - JSON string containing route metadata
-    /// * `handlers` - Ruby Hash mapping handler_name => Proc
-    /// * `config_value` - Ruby ServerConfig object
-    /// * `ws_handlers` - Ruby Hash of WebSocket handlers (optional)
-    /// * `sse_producers` - Ruby Hash of SSE producers (optional)
-    pub fn initialize(
-        ruby: &Ruby,
-        this: &Self,
-        routes_json: String,
-        handlers: Value,
-        config_value: Value,
-        ws_handlers: Value,
-        sse_producers: Value,
-    ) -> Result<(), Error> {
-        let metadata: Vec<RouteMetadata> = serde_json::from_str(&routes_json)
-            .map_err(|err| Error::new(ruby.exception_arg_error(), format!("Invalid routes JSON: {err}")))?;
-
-        let handlers_hash = RHash::from_value(handlers).ok_or_else(|| {
-            Error::new(
-                ruby.exception_arg_error(),
-                "handlers parameter must be a Hash of handler_name => Proc",
-            )
-        })?;
-
-        let json_module = ruby
-            .class_object()
-            .const_get("JSON")
-            .map_err(|_| Error::new(ruby.exception_runtime_error(), "JSON module not available"))?;
-
-        let server_config = crate::config::extract_server_config(ruby, config_value)?;
-
-        let schema_registry = spikard_http::SchemaRegistry::new();
-        let mut prepared_routes = Vec::with_capacity(metadata.len());
-        let mut handler_refs = Vec::with_capacity(metadata.len());
-        let mut route_metadata_vec = Vec::with_capacity(metadata.len());
-
-        for meta in metadata.clone() {
-            let handler_value = crate::conversion::fetch_handler(ruby, &handlers_hash, &meta.handler_name)?;
-            let route = Route::from_metadata(meta.clone(), &schema_registry)
-                .map_err(|err| Error::new(ruby.exception_runtime_error(), format!("Failed to build route: {err}")))?;
-
-            let handler = RubyHandler::new(&route, handler_value, json_module)?;
-            prepared_routes.push((route, Arc::new(handler.clone()) as Arc<dyn spikard_http::Handler>));
-            handler_refs.push(handler);
-            route_metadata_vec.push(meta);
-        }
-
-        let mut router = spikard_http::server::build_router_with_handlers_and_config(
-            prepared_routes,
-            server_config,
-            route_metadata_vec,
-        )
-        .map_err(|err| Error::new(ruby.exception_runtime_error(), format!("Failed to build router: {err}")))?;
-
-        let mut ws_endpoints = Vec::new();
-        if !ws_handlers.is_nil() {
-            let ws_hash = RHash::from_value(ws_handlers)
-                .ok_or_else(|| Error::new(ruby.exception_arg_error(), "WebSocket handlers must be a Hash"))?;
-
-            ws_hash.foreach(
-                |path: String, factory: Value| -> Result<magnus::r_hash::ForEach, Error> {
-                    let handler_instance = factory.funcall::<_, _, Value>("call", ()).map_err(|e| {
-                        Error::new(
-                            ruby.exception_runtime_error(),
-                            format!("Failed to create WebSocket handler: {}", e),
-                        )
-                    })?;
-
-                    let ws_state = crate::websocket::create_websocket_state(ruby, handler_instance)?;
-
-                    ws_endpoints.push((path, ws_state));
-
-                    Ok(magnus::r_hash::ForEach::Continue)
-                },
-            )?;
-        }
-
-        let mut sse_endpoints = Vec::new();
-        if !sse_producers.is_nil() {
-            let sse_hash = RHash::from_value(sse_producers)
-                .ok_or_else(|| Error::new(ruby.exception_arg_error(), "SSE producers must be a Hash"))?;
-
-            sse_hash.foreach(
-                |path: String, factory: Value| -> Result<magnus::r_hash::ForEach, Error> {
-                    let producer_instance = factory.funcall::<_, _, Value>("call", ()).map_err(|e| {
-                        Error::new(
-                            ruby.exception_runtime_error(),
-                            format!("Failed to create SSE producer: {}", e),
-                        )
-                    })?;
-
-                    let sse_state = crate::sse::create_sse_state(ruby, producer_instance)?;
-
-                    sse_endpoints.push((path, sse_state));
-
-                    Ok(magnus::r_hash::ForEach::Continue)
-                },
-            )?;
-        }
-
-        use axum::routing::get;
-        for (path, ws_state) in ws_endpoints {
-            router = router.route(
-                &path,
-                get(spikard_http::websocket_handler::<crate::websocket::RubyWebSocketHandler>).with_state(ws_state),
-            );
-        }
-
-        for (path, sse_state) in sse_endpoints {
-            router = router.route(
-                &path,
-                get(spikard_http::sse_handler::<crate::sse::RubySseEventProducer>).with_state(sse_state),
-            );
-        }
-
-        let http_server = GLOBAL_RUNTIME
-            .block_on(async { TestServer::new(router.clone()) })
-            .map_err(|err| {
-                Error::new(
-                    ruby.exception_runtime_error(),
-                    format!("Failed to initialise test server: {err}"),
-                )
-            })?;
-
-        let ws_config = TestServerConfig {
-            transport: Some(Transport::HttpRandomPort),
-            ..Default::default()
-        };
-        let transport_server = GLOBAL_RUNTIME
-            .block_on(async { TestServer::new_with_config(router, ws_config) })
-            .map_err(|err| {
-                Error::new(
-                    ruby.exception_runtime_error(),
-                    format!("Failed to initialise WebSocket transport server: {err}"),
-                )
-            })?;
-
-        *this.inner.borrow_mut() = Some(ClientInner {
-            http_server: Arc::new(http_server),
-            transport_server: Arc::new(transport_server),
-            handlers: handler_refs,
-        });
-
-        Ok(())
-    }
-
-    /// Execute an HTTP request against the test server.
-    ///
-    /// # Arguments
-    ///
-    /// * `ruby` - Ruby VM reference
-    /// * `this` - The wrapped NativeTestClient instance
-    /// * `method` - HTTP method (GET, POST, etc.)
-    /// * `path` - URL path
-    /// * `options` - Ruby Hash with query, headers, cookies, body, etc.
-    pub fn request(ruby: &Ruby, this: &Self, method: String, path: String, options: Value) -> Result<Value, Error> {
-        let inner_borrow = this.inner.borrow();
-        let inner = inner_borrow
-            .as_ref()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "TestClient not initialised"))?;
-        let method_upper = method.to_ascii_uppercase();
-        let http_method = Method::from_bytes(method_upper.as_bytes()).map_err(|err| {
-            Error::new(
-                ruby.exception_arg_error(),
-                format!("Unsupported method {method_upper}: {err}"),
-            )
-        })?;
-
-        let request_config = parse_request_config(ruby, options)?;
-
-        let response = GLOBAL_RUNTIME
-            .block_on(execute_request(
-                inner.http_server.clone(),
-                http_method,
-                path.clone(),
-                request_config,
-            ))
-            .map_err(|err| {
-                Error::new(
-                    ruby.exception_runtime_error(),
-                    format!("Request failed for {method_upper} {path}: {}", err.0),
-                )
-            })?;
-
-        response_to_ruby(ruby, response)
-    }
-
-    /// Close the test client and clean up resources.
-    pub fn close(&self) -> Result<(), Error> {
-        *self.inner.borrow_mut() = None;
-        Ok(())
-    }
-
-    /// Connect to a WebSocket endpoint on the test server.
-    pub fn websocket(ruby: &Ruby, this: &Self, path: String) -> Result<Value, Error> {
-        let inner_borrow = this.inner.borrow();
-        let inner = inner_borrow
-            .as_ref()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "TestClient not initialised"))?;
-
-        let server = Arc::clone(&inner.transport_server);
-
-        drop(inner_borrow);
-
-        let handle =
-            GLOBAL_RUNTIME.spawn(async move { spikard_http::testing::connect_websocket(&server, &path).await });
-
-        let ws = GLOBAL_RUNTIME.block_on(async {
-            handle
-                .await
-                .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("WebSocket task failed: {}", e)))
-        })?;
-
-        let ws_conn = crate::test_websocket::WebSocketTestConnection::new(ws);
-        Ok(ruby.obj_wrap(ws_conn).as_value())
-    }
-
-    /// Connect to an SSE endpoint on the test server.
-    pub fn sse(ruby: &Ruby, this: &Self, path: String) -> Result<Value, Error> {
-        let inner_borrow = this.inner.borrow();
-        let inner = inner_borrow
-            .as_ref()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "TestClient not initialised"))?;
-
-        let response = GLOBAL_RUNTIME
-            .block_on(async {
-                let axum_response = inner.transport_server.get(&path).await;
-                snapshot_response(axum_response).await
-            })
-            .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("SSE request failed: {}", e)))?;
-
-        crate::test_sse::sse_stream_from_response(ruby, &response)
-    }
-
-    /// GC mark hook so Ruby keeps handler closures alive.
-    #[allow(dead_code)]
-    pub fn mark(&self, marker: &Marker) {
-        let inner_ref = self.inner.borrow();
-        if let Some(inner) = inner_ref.as_ref() {
-            for handler in &inner.handlers {
-                handler.mark(marker);
-            }
-        }
-    }
-}
-
-/// Execute an HTTP request against a test server.
-///
-/// Handles method routing, query params, headers, cookies, and various body formats.
-pub async fn execute_request(
-    server: Arc<TestServer>,
-    method: Method,
-    path: String,
-    config: RequestConfig,
-) -> Result<TestResponseData, NativeRequestError> {
-    let mut request = match method {
-        Method::GET => server.get(&path),
-        Method::POST => server.post(&path),
-        Method::PUT => server.put(&path),
-        Method::PATCH => server.patch(&path),
-        Method::DELETE => server.delete(&path),
-        Method::HEAD => server.method(Method::HEAD, &path),
-        Method::OPTIONS => server.method(Method::OPTIONS, &path),
-        Method::TRACE => server.method(Method::TRACE, &path),
-        other => return Err(NativeRequestError(format!("Unsupported HTTP method {other}"))),
-    };
-
-    if let Some(query) = config.query {
-        request = request.add_query_params(&query);
-    }
-
-    for (name, value) in config.headers {
-        request = request.add_header(name.as_str(), value.as_str());
-    }
-
-    for (name, value) in config.cookies {
-        request = request.add_cookie(Cookie::new(name, value));
-    }
-
-    if let Some(body) = config.body {
-        match body {
-            RequestBody::Json(json_value) => {
-                request = request.json(&json_value);
-            }
-            RequestBody::Form(form_value) => {
-                let encoded = encode_urlencoded_body(&form_value)
-                    .map_err(|err| NativeRequestError(format!("Failed to encode form body: {err}")))?;
-                request = request
-                    .content_type("application/x-www-form-urlencoded")
-                    .bytes(Bytes::from(encoded));
-            }
-            RequestBody::Raw(raw) => {
-                request = request.bytes(Bytes::from(raw));
-            }
-            RequestBody::Multipart { form_data, files } => {
-                let (multipart_body, boundary) = build_multipart_body(&form_data, &files);
-                request = request
-                    .content_type(&format!("multipart/form-data; boundary={}", boundary))
-                    .bytes(Bytes::from(multipart_body));
-            }
-        }
-    }
-
-    let response = request.await;
-    let snapshot = snapshot_response(response).await.map_err(snapshot_err_to_native)?;
-    let body_text = if snapshot.body.is_empty() {
-        None
-    } else {
-        Some(String::from_utf8_lossy(&snapshot.body).into_owned())
-    };
-
-    Ok(TestResponseData {
-        status: snapshot.status,
-        headers: snapshot.headers,
-        body_text,
-    })
-}
-
-fn snapshot_err_to_native(err: SnapshotError) -> NativeRequestError {
-    NativeRequestError(err.to_string())
-}