spikard 0.3.6 → 0.5.0

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

@@ -6,6 +6,8 @@
 use magnus::{RHash, Value, prelude::*, value::Opaque};
 use serde_json::Value as JsonValue;
 use spikard_http::WebSocketHandler;
+use std::sync::mpsc;
+use tokio::sync::oneshot;
 use tracing::{debug, error};
 
 /// Ruby implementation of WebSocketHandler
@@ -13,27 +15,68 @@ pub struct RubyWebSocketHandler {
     /// Handler name for debugging
     name: String,
     /// Ruby proc/callable for handle_message (Opaque for Send safety)
+    #[allow(dead_code)]
     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>>,
+    /// Work queue for executing Ruby callbacks on a Ruby thread
+    work_tx: mpsc::Sender<WebSocketWorkItem>,
+}
+
+enum WebSocketWorkItem {
+    HandleMessage {
+        message: JsonValue,
+        reply: oneshot::Sender<Result<Option<JsonValue>, String>>,
+    },
+    OnConnect {
+        reply: oneshot::Sender<Result<(), String>>,
+    },
+    OnDisconnect {
+        reply: oneshot::Sender<Result<(), String>>,
+    },
+    Shutdown,
 }
 
 impl RubyWebSocketHandler {
     /// Create a new Ruby WebSocket handler
     #[allow(dead_code)]
     pub fn new(
+        ruby: &magnus::Ruby,
         name: String,
         handle_message_proc: Value,
         on_connect_proc: Option<Value>,
         on_disconnect_proc: Option<Value>,
     ) -> Self {
+        let handle_message_proc = Opaque::from(handle_message_proc);
+        let on_connect_proc = on_connect_proc.map(Opaque::from);
+        let on_disconnect_proc = on_disconnect_proc.map(Opaque::from);
+        let (work_tx, work_rx) = mpsc::channel();
+        let handler_name = name.clone();
+
+        let handle_message_proc_for_thread = handle_message_proc;
+        let on_connect_proc_for_thread = on_connect_proc;
+        let on_disconnect_proc_for_thread = on_disconnect_proc;
+
+        ruby.thread_create_from_fn(move |ruby| {
+            websocket_worker_loop(
+                ruby,
+                &handler_name,
+                handle_message_proc_for_thread,
+                on_connect_proc_for_thread,
+                on_disconnect_proc_for_thread,
+                work_rx,
+            );
+            ruby.qnil()
+        });
+
         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()),
+            handle_message_proc,
+            on_connect_proc,
+            on_disconnect_proc,
+            work_tx,
         }
     }
 
@@ -100,22 +143,25 @@ 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 (reply_tx, reply_rx) = oneshot::channel();
+        if self
+            .work_tx
+            .send(WebSocketWorkItem::HandleMessage { message, reply: reply_tx })
+            .is_err()
+        {
+            error!("Ruby WebSocket handler '{}' worker thread closed", self.name);
+            return None;
+        }
 
-                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))?;
+        let result = match reply_rx.await {
+            Ok(result) => result,
+            Err(_) => {
+                error!("Ruby WebSocket handler '{}' response channel closed", self.name);
+                return None;
+            }
+        };
 
-                if result.is_nil() {
-                    Ok(None)
-                } else {
-                    Self::ruby_to_json(&ruby, result).map(Some)
-                }
-            }) {
+        match result {
             Ok(value) => value,
             Err(e) => {
                 error!("Ruby error in handle_message: {}", e);
@@ -127,17 +173,26 @@ impl WebSocketHandler for RubyWebSocketHandler {
     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(())
-                })
+        if self.on_connect_proc.is_some() {
+            let (reply_tx, reply_rx) = oneshot::channel();
+            if self
+                .work_tx
+                .send(WebSocketWorkItem::OnConnect { reply: reply_tx })
+                .is_err()
             {
+                error!("Ruby WebSocket handler '{}' worker thread closed", self.name);
+                return;
+            }
+
+            let result = match reply_rx.await {
+                Ok(result) => result,
+                Err(_) => {
+                    error!("Ruby WebSocket handler '{}' on_connect channel closed", self.name);
+                    return;
+                }
+            };
+
+            if let Err(e) = result {
                 error!("on_connect error: {}", e);
             }
 
@@ -148,17 +203,26 @@ impl WebSocketHandler for RubyWebSocketHandler {
     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(())
-                })
+        if self.on_disconnect_proc.is_some() {
+            let (reply_tx, reply_rx) = oneshot::channel();
+            if self
+                .work_tx
+                .send(WebSocketWorkItem::OnDisconnect { reply: reply_tx })
+                .is_err()
             {
+                error!("Ruby WebSocket handler '{}' worker thread closed", self.name);
+                return;
+            }
+
+            let result = match reply_rx.await {
+                Ok(result) => result,
+                Err(_) => {
+                    error!("Ruby WebSocket handler '{}' on_disconnect channel closed", self.name);
+                    return;
+                }
+            };
+
+            if let Err(e) = result {
                 error!("on_disconnect error: {}", e);
             }
 
@@ -167,6 +231,82 @@ impl WebSocketHandler for RubyWebSocketHandler {
     }
 }
 
+impl Drop for RubyWebSocketHandler {
+    fn drop(&mut self) {
+        let _ = self.work_tx.send(WebSocketWorkItem::Shutdown);
+    }
+}
+
+fn websocket_worker_loop(
+    ruby: &magnus::Ruby,
+    handler_name: &str,
+    handle_message_proc: Opaque<Value>,
+    on_connect_proc: Option<Opaque<Value>>,
+    on_disconnect_proc: Option<Opaque<Value>>,
+    work_rx: mpsc::Receiver<WebSocketWorkItem>,
+) {
+    let work_rx_ref = &work_rx;
+    loop {
+        let work = crate::call_without_gvl!(
+            recv_work_item,
+            args: (work_rx_ref, &mpsc::Receiver<WebSocketWorkItem>),
+            return_type: Option<WebSocketWorkItem>
+        );
+        let Some(work) = work else {
+            break;
+        };
+
+        match work {
+            WebSocketWorkItem::HandleMessage { message, reply } => {
+                let result = (|| {
+                    let message_ruby = RubyWebSocketHandler::json_to_ruby(ruby, &message)?;
+                    let proc_value = ruby.get_inner(handle_message_proc);
+                    let result: Value = proc_value
+                        .funcall("call", (message_ruby,))
+                        .map_err(|e| format!("Handler '{}' call failed: {}", handler_name, e))?;
+                    if result.is_nil() {
+                        Ok(None)
+                    } else {
+                        RubyWebSocketHandler::ruby_to_json(ruby, result).map(Some)
+                    }
+                })();
+                let _ = reply.send(result);
+            }
+            WebSocketWorkItem::OnConnect { reply } => {
+                let result = on_connect_proc
+                    .map(|proc| {
+                        let proc_value = ruby.get_inner(proc);
+                        proc_value
+                            .funcall::<_, _, Value>("call", ())
+                            .map_err(|e| format!("on_connect '{}' call failed: {}", handler_name, e))?;
+                        Ok(())
+                    })
+                    .unwrap_or(Ok(()));
+                let _ = reply.send(result);
+            }
+            WebSocketWorkItem::OnDisconnect { reply } => {
+                let result = on_disconnect_proc
+                    .map(|proc| {
+                        let proc_value = ruby.get_inner(proc);
+                        proc_value
+                            .funcall::<_, _, Value>("call", ())
+                            .map_err(|e| format!("on_disconnect '{}' call failed: {}", handler_name, e))?;
+                        Ok(())
+                    })
+                    .unwrap_or(Ok(()));
+                let _ = reply.send(result);
+            }
+            WebSocketWorkItem::Shutdown => {
+                break;
+            }
+        }
+    }
+}
+
+fn recv_work_item(receiver: &mpsc::Receiver<WebSocketWorkItem>) -> Option<WebSocketWorkItem> {
+    receiver.recv().ok()
+}
+
 unsafe impl Send for RubyWebSocketHandler {}
 unsafe impl Sync for RubyWebSocketHandler {}
 
@@ -218,6 +358,7 @@ pub fn create_websocket_state(
         });
 
     let ruby_handler = RubyWebSocketHandler::new(
+        ruby,
         "WebSocketHandler".to_string(),
         handle_message_proc,
         on_connect_proc,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spikard
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.5.0
 platform: ruby
 authors:
 - Na'aman Hirschfeld
@@ -69,6 +69,22 @@ files:
 - sig/spikard.rbs
 - vendor/bundle/ruby/3.4.0/gems/diff-lcs-1.6.2/mise.toml
 - vendor/bundle/ruby/3.4.0/gems/rake-compiler-dock-1.10.0/build/buildkitd.toml
+- vendor/crates/spikard-bindings-shared/Cargo.toml
+- vendor/crates/spikard-bindings-shared/examples/config_extraction.rs
+- vendor/crates/spikard-bindings-shared/src/config_extractor.rs
+- vendor/crates/spikard-bindings-shared/src/conversion_traits.rs
+- vendor/crates/spikard-bindings-shared/src/di_traits.rs
+- vendor/crates/spikard-bindings-shared/src/error_response.rs
+- vendor/crates/spikard-bindings-shared/src/handler_base.rs
+- vendor/crates/spikard-bindings-shared/src/lib.rs
+- vendor/crates/spikard-bindings-shared/src/lifecycle_base.rs
+- vendor/crates/spikard-bindings-shared/src/lifecycle_executor.rs
+- vendor/crates/spikard-bindings-shared/src/response_builder.rs
+- vendor/crates/spikard-bindings-shared/src/test_client_base.rs
+- vendor/crates/spikard-bindings-shared/src/validation_helpers.rs
+- vendor/crates/spikard-bindings-shared/tests/comprehensive_coverage.rs
+- vendor/crates/spikard-bindings-shared/tests/error_response_edge_cases.rs
+- vendor/crates/spikard-bindings-shared/tests/handler_base_integration.rs
 - vendor/crates/spikard-core/Cargo.toml
 - vendor/crates/spikard-core/src/bindings/mod.rs
 - vendor/crates/spikard-core/src/bindings/response.rs
@@ -85,14 +101,18 @@ files:
 - vendor/crates/spikard-core/src/http.rs
 - vendor/crates/spikard-core/src/lib.rs
 - vendor/crates/spikard-core/src/lifecycle.rs
+- vendor/crates/spikard-core/src/metadata.rs
 - vendor/crates/spikard-core/src/parameters.rs
 - vendor/crates/spikard-core/src/problem.rs
 - vendor/crates/spikard-core/src/request_data.rs
 - vendor/crates/spikard-core/src/router.rs
 - vendor/crates/spikard-core/src/schema_registry.rs
 - vendor/crates/spikard-core/src/type_hints.rs
-- vendor/crates/spikard-core/src/validation.rs
+- vendor/crates/spikard-core/src/validation/error_mapper.rs
+- vendor/crates/spikard-core/src/validation/mod.rs
 - vendor/crates/spikard-http/Cargo.toml
+- vendor/crates/spikard-http/examples/sse-notifications.rs
+- vendor/crates/spikard-http/examples/websocket-chat.rs
 - vendor/crates/spikard-http/src/auth.rs
 - vendor/crates/spikard-http/src/background.rs
 - vendor/crates/spikard-http/src/bindings/mod.rs
@@ -115,38 +135,51 @@ files:
 - vendor/crates/spikard-http/src/openapi/parameter_extraction.rs
 - vendor/crates/spikard-http/src/openapi/schema_conversion.rs
 - vendor/crates/spikard-http/src/openapi/spec_generation.rs
-- vendor/crates/spikard-http/src/parameters.rs
-- vendor/crates/spikard-http/src/problem.rs
 - vendor/crates/spikard-http/src/query_parser.rs
 - vendor/crates/spikard-http/src/response.rs
-- vendor/crates/spikard-http/src/router.rs
-- vendor/crates/spikard-http/src/schema_registry.rs
 - vendor/crates/spikard-http/src/server/handler.rs
 - vendor/crates/spikard-http/src/server/lifecycle_execution.rs
 - vendor/crates/spikard-http/src/server/mod.rs
 - vendor/crates/spikard-http/src/server/request_extraction.rs
+- vendor/crates/spikard-http/src/server/routing_factory.rs
 - vendor/crates/spikard-http/src/sse.rs
 - vendor/crates/spikard-http/src/testing.rs
 - vendor/crates/spikard-http/src/testing/form.rs
 - vendor/crates/spikard-http/src/testing/multipart.rs
 - vendor/crates/spikard-http/src/testing/test_client.rs
-- vendor/crates/spikard-http/src/type_hints.rs
-- vendor/crates/spikard-http/src/validation.rs
 - vendor/crates/spikard-http/src/websocket.rs
+- vendor/crates/spikard-http/tests/background_behavior.rs
+- vendor/crates/spikard-http/tests/common/handlers.rs
+- vendor/crates/spikard-http/tests/common/mod.rs
+- vendor/crates/spikard-http/tests/di_integration.rs
+- vendor/crates/spikard-http/tests/doc_snippets.rs
+- vendor/crates/spikard-http/tests/lifecycle_execution.rs
+- vendor/crates/spikard-http/tests/multipart_behavior.rs
+- vendor/crates/spikard-http/tests/server_config_builder.rs
+- vendor/crates/spikard-http/tests/sse_behavior.rs
+- vendor/crates/spikard-http/tests/websocket_behavior.rs
 - vendor/crates/spikard-rb/Cargo.toml
 - vendor/crates/spikard-rb/build.rs
 - vendor/crates/spikard-rb/src/background.rs
-- vendor/crates/spikard-rb/src/config.rs
+- vendor/crates/spikard-rb/src/config/mod.rs
+- vendor/crates/spikard-rb/src/config/server_config.rs
 - vendor/crates/spikard-rb/src/conversion.rs
-- vendor/crates/spikard-rb/src/di.rs
+- vendor/crates/spikard-rb/src/di/builder.rs
+- vendor/crates/spikard-rb/src/di/mod.rs
 - vendor/crates/spikard-rb/src/handler.rs
+- vendor/crates/spikard-rb/src/integration/mod.rs
 - vendor/crates/spikard-rb/src/lib.rs
 - vendor/crates/spikard-rb/src/lifecycle.rs
+- vendor/crates/spikard-rb/src/metadata/mod.rs
+- vendor/crates/spikard-rb/src/metadata/route_extraction.rs
+- vendor/crates/spikard-rb/src/runtime/mod.rs
+- vendor/crates/spikard-rb/src/runtime/server_runner.rs
 - vendor/crates/spikard-rb/src/server.rs
 - vendor/crates/spikard-rb/src/sse.rs
-- vendor/crates/spikard-rb/src/test_client.rs
-- vendor/crates/spikard-rb/src/test_sse.rs
-- vendor/crates/spikard-rb/src/test_websocket.rs
+- vendor/crates/spikard-rb/src/testing/client.rs
+- vendor/crates/spikard-rb/src/testing/mod.rs
+- vendor/crates/spikard-rb/src/testing/sse.rs
+- vendor/crates/spikard-rb/src/testing/websocket.rs
 - vendor/crates/spikard-rb/src/websocket.rs
 homepage: https://github.com/Goldziher/spikard
 licenses:

data/vendor/crates/spikard-http/src/parameters.rs

@@ -1 +0,0 @@
-pub use spikard_core::parameters::*;

data/vendor/crates/spikard-http/src/problem.rs

@@ -1 +0,0 @@
-pub use spikard_core::problem::*;

data/vendor/crates/spikard-http/src/router.rs

@@ -1 +0,0 @@
-pub use spikard_core::router::*;

data/vendor/crates/spikard-http/src/schema_registry.rs

@@ -1 +0,0 @@
-pub use spikard_core::schema_registry::*;

data/vendor/crates/spikard-http/src/type_hints.rs

@@ -1 +0,0 @@
-pub use spikard_core::type_hints::*;

data/vendor/crates/spikard-http/src/validation.rs

@@ -1 +0,0 @@
-pub use spikard_core::validation::*;

data/vendor/crates/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(())
-}