spikard 0.3.4 → 0.3.6

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

@@ -1,143 +0,0 @@
-//! SSE test client bindings for Ruby
-
-use magnus::prelude::*;
-use magnus::{Error, Ruby, Value, method};
-use serde_json::Value as JsonValue;
-use spikard_http::testing::{ResponseSnapshot, SseEvent as RustSseEvent, SseStream as RustSseStream};
-
-/// Ruby wrapper for SSE stream
-#[magnus::wrap(class = "Spikard::Native::SseStream", free_immediately)]
-pub struct SseStream {
-    inner: RustSseStream,
-}
-
-impl SseStream {
-    pub fn new(inner: RustSseStream) -> Self {
-        Self { inner }
-    }
-
-    /// Get the raw body of the SSE response
-    fn body(&self) -> String {
-        self.inner.body().to_string()
-    }
-
-    /// Get all events from the stream
-    fn events(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        let ruby_arr = ruby.ary_new();
-        for event in this.inner.events() {
-            let sse_event = SseEvent::new(event.clone());
-            let ruby_event = ruby.obj_wrap(sse_event);
-            ruby_arr.push(ruby_event)?;
-        }
-        Ok(ruby_arr.as_value())
-    }
-
-    /// Get events as JSON values
-    fn events_as_json(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        let json_events = this.inner.events_as_json().map_err(|e| {
-            Error::new(
-                ruby.exception_runtime_error(),
-                format!("Failed to parse events as JSON: {}", e),
-            )
-        })?;
-
-        let ruby_arr = ruby.ary_new();
-        for value in json_events {
-            let ruby_val = json_to_ruby(ruby, &value)?;
-            ruby_arr.push(ruby_val)?;
-        }
-        Ok(ruby_arr.as_value())
-    }
-}
-
-/// Ruby wrapper for SSE event
-#[magnus::wrap(class = "Spikard::Native::SseEvent", free_immediately)]
-pub struct SseEvent {
-    inner: RustSseEvent,
-}
-
-impl SseEvent {
-    pub fn new(inner: RustSseEvent) -> Self {
-        Self { inner }
-    }
-
-    /// Get the data field of the event
-    fn data(&self) -> String {
-        self.inner.data.clone()
-    }
-
-    /// Parse the event data as JSON
-    fn as_json(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        let value = this
-            .inner
-            .as_json()
-            .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("Failed to parse JSON: {}", e)))?;
-
-        json_to_ruby(ruby, &value)
-    }
-}
-
-/// Create an SSE stream from a response snapshot
-pub fn sse_stream_from_response(ruby: &Ruby, response: &ResponseSnapshot) -> Result<Value, Error> {
-    let stream = RustSseStream::from_response(response)
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("Failed to parse SSE: {}", e)))?;
-
-    let sse_stream = SseStream::new(stream);
-    Ok(ruby.obj_wrap(sse_stream).as_value())
-}
-
-/// Helper to convert JSON to Ruby object
-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(n) => {
-            if let Some(i) = n.as_i64() {
-                Ok(ruby.integer_from_i64(i).as_value())
-            } else if let Some(u) = n.as_u64() {
-                Ok(ruby.integer_from_i64(u as i64).as_value())
-            } else if let Some(f) = n.as_f64() {
-                Ok(ruby.float_from_f64(f).as_value())
-            } else {
-                Ok(ruby.qnil().as_value())
-            }
-        }
-        JsonValue::String(s) => Ok(ruby.str_new(s).as_value()),
-        JsonValue::Array(arr) => {
-            let ruby_arr = ruby.ary_new();
-            for item in arr {
-                let ruby_val = json_to_ruby(ruby, item)?;
-                ruby_arr.push(ruby_val)?;
-            }
-            Ok(ruby_arr.as_value())
-        }
-        JsonValue::Object(obj) => {
-            let ruby_hash = ruby.hash_new();
-            for (key, val) in obj {
-                let ruby_val = json_to_ruby(ruby, val)?;
-                ruby_hash.aset(ruby.str_new(key), ruby_val)?;
-            }
-            Ok(ruby_hash.as_value())
-        }
-    }
-}
-
-/// Initialize SSE test client bindings
-pub fn init(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
-    let native_module = module.define_module("Native")?;
-
-    let sse_stream_class = native_module.define_class("SseStream", ruby.class_object())?;
-    sse_stream_class.define_method("body", method!(SseStream::body, 0))?;
-    sse_stream_class.define_method("events", method!(SseStream::events, 0))?;
-    sse_stream_class.define_method("events_as_json", method!(SseStream::events_as_json, 0))?;
-
-    let sse_event_class = native_module.define_class("SseEvent", ruby.class_object())?;
-    sse_event_class.define_method("data", method!(SseEvent::data, 0))?;
-    sse_event_class.define_method("as_json", method!(SseEvent::as_json, 0))?;
-
-    Ok(())
-}

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

@@ -1,221 +0,0 @@
-//! WebSocket test client bindings for Ruby
-
-use magnus::prelude::*;
-use magnus::{Error, Ruby, Value, method};
-use serde_json::Value as JsonValue;
-use spikard_http::testing::{WebSocketConnection as RustWebSocketConnection, WebSocketMessage as RustWebSocketMessage};
-use std::cell::RefCell;
-
-use crate::server::GLOBAL_RUNTIME;
-
-/// Ruby wrapper for WebSocket test client
-#[derive(Default)]
-#[magnus::wrap(class = "Spikard::Native::WebSocketTestConnection", free_immediately)]
-pub struct WebSocketTestConnection {
-    inner: RefCell<Option<RustWebSocketConnection>>,
-}
-
-impl WebSocketTestConnection {
-    /// Create a new WebSocket test connection (public for lib.rs)
-    pub(crate) fn new(inner: RustWebSocketConnection) -> Self {
-        Self {
-            inner: RefCell::new(Some(inner)),
-        }
-    }
-
-    /// Send a text message
-    fn send_text(&self, text: String) -> Result<(), Error> {
-        let mut inner = self.inner.borrow_mut();
-        let ws = inner
-            .as_mut()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "WebSocket closed"))?;
-
-        GLOBAL_RUNTIME.block_on(async {
-            ws.send_text(text).await;
-        });
-
-        Ok(())
-    }
-
-    /// Send a JSON message
-    fn send_json(ruby: &Ruby, this: &Self, obj: Value) -> Result<(), Error> {
-        let json_value = ruby_to_json(ruby, obj)?;
-        let mut inner = this.inner.borrow_mut();
-        let ws = inner
-            .as_mut()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "WebSocket closed"))?;
-
-        GLOBAL_RUNTIME.block_on(async {
-            ws.send_json(&json_value).await;
-        });
-
-        Ok(())
-    }
-
-    /// Receive a text message
-    fn receive_text(&self) -> Result<String, Error> {
-        let mut inner = self.inner.borrow_mut();
-        let ws = inner
-            .as_mut()
-            .ok_or_else(|| Error::new(magnus::exception::runtime_error(), "WebSocket closed"))?;
-
-        let text = GLOBAL_RUNTIME.block_on(async { ws.receive_text().await });
-
-        Ok(text)
-    }
-
-    /// Receive and parse a JSON message
-    fn receive_json(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        let mut inner = this.inner.borrow_mut();
-        let ws = inner
-            .as_mut()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "WebSocket closed"))?;
-
-        let json_value: JsonValue = GLOBAL_RUNTIME.block_on(async { ws.receive_json().await });
-
-        json_to_ruby(ruby, &json_value)
-    }
-
-    /// Receive raw bytes
-    fn receive_bytes(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        let mut inner = this.inner.borrow_mut();
-        let ws = inner
-            .as_mut()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "WebSocket closed"))?;
-
-        let bytes = GLOBAL_RUNTIME.block_on(async { ws.receive_bytes().await });
-
-        Ok(ruby.str_from_slice(&bytes).as_value())
-    }
-
-    /// Receive a message and return WebSocketMessage
-    fn receive_message(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        let mut inner = this.inner.borrow_mut();
-        let ws = inner
-            .as_mut()
-            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "WebSocket closed"))?;
-
-        let msg = GLOBAL_RUNTIME.block_on(async { ws.receive_message().await });
-
-        let ws_msg = WebSocketMessage::new(msg);
-        Ok(ruby.obj_wrap(ws_msg).as_value())
-    }
-
-    /// Close the WebSocket connection
-    fn close(&self) -> Result<(), Error> {
-        self.inner.borrow_mut().take();
-        Ok(())
-    }
-}
-
-/// Ruby wrapper for WebSocket messages
-#[magnus::wrap(class = "Spikard::Native::WebSocketMessage", free_immediately)]
-pub struct WebSocketMessage {
-    inner: RustWebSocketMessage,
-}
-
-impl WebSocketMessage {
-    pub fn new(inner: RustWebSocketMessage) -> Self {
-        Self { inner }
-    }
-
-    /// Get message as text if it's a text message
-    fn as_text(&self) -> Result<Option<String>, Error> {
-        Ok(self.inner.as_text().map(|s| s.to_string()))
-    }
-
-    /// Get message as JSON if it's a text message containing JSON
-    fn as_json(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        match this.inner.as_json() {
-            Ok(value) => json_to_ruby(ruby, &value),
-            Err(_) => Ok(ruby.qnil().as_value()),
-        }
-    }
-
-    /// Get message as binary if it's a binary message
-    fn as_binary(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-        match this.inner.as_binary() {
-            Some(bytes) => Ok(ruby.str_from_slice(bytes).as_value()),
-            None => Ok(ruby.qnil().as_value()),
-        }
-    }
-
-    /// Check if this is a close message
-    fn is_close(&self) -> bool {
-        self.inner.is_close()
-    }
-}
-
-/// Helper to convert Ruby object to JSON
-fn ruby_to_json(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
-    let json_module = ruby.class_object().const_get::<_, magnus::RModule>("JSON")?;
-    let json_str: String = json_module.funcall("generate", (value,))?;
-    serde_json::from_str(&json_str).map_err(|e| {
-        Error::new(
-            magnus::exception::runtime_error(),
-            format!("Failed to parse JSON: {}", e),
-        )
-    })
-}
-
-/// Helper to convert JSON to Ruby object
-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(n) => {
-            if let Some(i) = n.as_i64() {
-                Ok(ruby.integer_from_i64(i).as_value())
-            } else if let Some(u) = n.as_u64() {
-                Ok(ruby.integer_from_i64(u as i64).as_value())
-            } else if let Some(f) = n.as_f64() {
-                Ok(ruby.float_from_f64(f).as_value())
-            } else {
-                Ok(ruby.qnil().as_value())
-            }
-        }
-        JsonValue::String(s) => Ok(ruby.str_new(s).as_value()),
-        JsonValue::Array(arr) => {
-            let ruby_arr = ruby.ary_new();
-            for item in arr {
-                let ruby_val = json_to_ruby(ruby, item)?;
-                ruby_arr.push(ruby_val)?;
-            }
-            Ok(ruby_arr.as_value())
-        }
-        JsonValue::Object(obj) => {
-            let ruby_hash = ruby.hash_new();
-            for (key, val) in obj {
-                let ruby_val = json_to_ruby(ruby, val)?;
-                ruby_hash.aset(ruby.str_new(key), ruby_val)?;
-            }
-            Ok(ruby_hash.as_value())
-        }
-    }
-}
-
-/// Initialize WebSocket test client bindings
-pub fn init(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
-    let native_module = module.define_module("Native")?;
-
-    let ws_conn_class = native_module.define_class("WebSocketTestConnection", ruby.class_object())?;
-    ws_conn_class.define_method("send_text", method!(WebSocketTestConnection::send_text, 1))?;
-    ws_conn_class.define_method("send_json", method!(WebSocketTestConnection::send_json, 1))?;
-    ws_conn_class.define_method("receive_text", method!(WebSocketTestConnection::receive_text, 0))?;
-    ws_conn_class.define_method("receive_json", method!(WebSocketTestConnection::receive_json, 0))?;
-    ws_conn_class.define_method("receive_bytes", method!(WebSocketTestConnection::receive_bytes, 0))?;
-    ws_conn_class.define_method("receive_message", method!(WebSocketTestConnection::receive_message, 0))?;
-    ws_conn_class.define_method("close", method!(WebSocketTestConnection::close, 0))?;
-
-    let ws_msg_class = native_module.define_class("WebSocketMessage", ruby.class_object())?;
-    ws_msg_class.define_method("as_text", method!(WebSocketMessage::as_text, 0))?;
-    ws_msg_class.define_method("as_json", method!(WebSocketMessage::as_json, 0))?;
-    ws_msg_class.define_method("as_binary", method!(WebSocketMessage::as_binary, 0))?;
-    ws_msg_class.define_method("is_close", method!(WebSocketMessage::is_close, 0))?;
-
-    Ok(())
-}

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

@@ -1,233 +0,0 @@
-//! Ruby WebSocket handler bindings
-//!
-//! This module provides the bridge between Ruby blocks/procs and Rust's WebSocket 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::WebSocketHandler;
-use tracing::{debug, error};
-
-/// Ruby implementation of WebSocketHandler
-pub struct RubyWebSocketHandler {
-    /// Handler name for debugging
-    name: String,
-    /// Ruby proc/callable for handle_message (Opaque for Send safety)
-    handle_message_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 RubyWebSocketHandler {
-    /// Create a new Ruby WebSocket handler
-    #[allow(dead_code)]
-    pub fn new(
-        name: String,
-        handle_message_proc: Value,
-        on_connect_proc: Option<Value>,
-        on_disconnect_proc: Option<Value>,
-    ) -> Self {
-        Self {
-            name,
-            handle_message_proc: handle_message_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))
-    }
-
-    /// Convert JSON value to Ruby value
-    fn json_to_ruby(ruby: &magnus::Ruby, value: &JsonValue) -> Result<Value, String> {
-        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(s) => Ok(ruby.str_new(s).as_value()),
-            JsonValue::Array(arr) => {
-                let ruby_array = ruby.ary_new();
-                for item in arr {
-                    ruby_array
-                        .push(Self::json_to_ruby(ruby, item)?)
-                        .map_err(|e| format!("Failed to push to array: {}", e))?;
-                }
-                Ok(ruby_array.as_value())
-            }
-            JsonValue::Object(obj) => {
-                let ruby_hash = RHash::new();
-                for (key, val) in obj {
-                    ruby_hash
-                        .aset(ruby.str_new(key), Self::json_to_ruby(ruby, val)?)
-                        .map_err(|e| format!("Failed to set hash value: {}", e))?;
-                }
-                Ok(ruby_hash.as_value())
-            }
-        }
-    }
-}
-
-impl WebSocketHandler for RubyWebSocketHandler {
-    async fn handle_message(&self, message: JsonValue) -> Option<JsonValue> {
-        debug!("Ruby WebSocket handler '{}': handle_message", self.name);
-
-        match magnus::Ruby::get()
-            .map_err(|e| format!("Failed to get Ruby: {}", e))
-            .and_then(|ruby| {
-                let message_ruby = Self::json_to_ruby(&ruby, &message)?;
-
-                let proc_value = ruby.get_inner(self.handle_message_proc);
-                let result: Value = proc_value
-                    .funcall("call", (message_ruby,))
-                    .map_err(|e| format!("Handler '{}' call failed: {}", self.name, e))?;
-
-                if result.is_nil() {
-                    Ok(None)
-                } else {
-                    Self::ruby_to_json(&ruby, result).map(Some)
-                }
-            }) {
-            Ok(value) => value,
-            Err(e) => {
-                error!("Ruby error in handle_message: {}", e);
-                None
-            }
-        }
-    }
-
-    async fn on_connect(&self) {
-        debug!("Ruby WebSocket handler '{}': on_connect", self.name);
-
-        if let Some(on_connect_proc) = self.on_connect_proc {
-            if 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_connect_proc);
-                    proc_value
-                        .funcall::<_, _, Value>("call", ())
-                        .map_err(|e| format!("on_connect '{}' call failed: {}", self.name, e))?;
-                    Ok(())
-                })
-            {
-                error!("on_connect error: {}", e);
-            }
-
-            debug!("Ruby WebSocket handler '{}': on_connect completed", self.name);
-        }
-    }
-
-    async fn on_disconnect(&self) {
-        debug!("Ruby WebSocket handler '{}': on_disconnect", self.name);
-
-        if let Some(on_disconnect_proc) = self.on_disconnect_proc {
-            if 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))?;
-                    Ok(())
-                })
-            {
-                error!("on_disconnect error: {}", e);
-            }
-
-            debug!("Ruby WebSocket handler '{}': on_disconnect completed", self.name);
-        }
-    }
-}
-
-unsafe impl Send for RubyWebSocketHandler {}
-unsafe impl Sync for RubyWebSocketHandler {}
-
-/// Create WebSocketState from Ruby handler object
-///
-/// This function is designed to be called from Ruby to register WebSocket handlers.
-#[allow(dead_code)]
-pub fn create_websocket_state(
-    ruby: &magnus::Ruby,
-    handler_obj: Value,
-) -> Result<spikard_http::WebSocketState<RubyWebSocketHandler>, magnus::Error> {
-    let handle_message_proc: Value = handler_obj
-        .funcall("method", (ruby.to_symbol("handle_message"),))
-        .map_err(|e| {
-            magnus::Error::new(
-                ruby.exception_arg_error(),
-                format!("handle_message method not found: {}", e),
-            )
-        })?;
-
-    let on_connect_proc = handler_obj
-        .funcall::<_, _, Value>("method", (ruby.to_symbol("on_connect"),))
-        .ok();
-
-    let on_disconnect_proc = handler_obj
-        .funcall::<_, _, Value>("method", (ruby.to_symbol("on_disconnect"),))
-        .ok();
-
-    let message_schema = handler_obj
-        .funcall::<_, _, Value>("instance_variable_get", (ruby.to_symbol("@_message_schema"),))
-        .ok()
-        .and_then(|v| {
-            if v.is_nil() {
-                None
-            } else {
-                RubyWebSocketHandler::ruby_to_json(ruby, v).ok()
-            }
-        });
-
-    let response_schema = handler_obj
-        .funcall::<_, _, Value>("instance_variable_get", (ruby.to_symbol("@_response_schema"),))
-        .ok()
-        .and_then(|v| {
-            if v.is_nil() {
-                None
-            } else {
-                RubyWebSocketHandler::ruby_to_json(ruby, v).ok()
-            }
-        });
-
-    let ruby_handler = RubyWebSocketHandler::new(
-        "WebSocketHandler".to_string(),
-        handle_message_proc,
-        on_connect_proc,
-        on_disconnect_proc,
-    );
-
-    if message_schema.is_some() || response_schema.is_some() {
-        spikard_http::WebSocketState::with_schemas(ruby_handler, message_schema, response_schema)
-            .map_err(|e| magnus::Error::new(ruby.exception_runtime_error(), e))
-    } else {
-        Ok(spikard_http::WebSocketState::new(ruby_handler))
-    }
-}