zzq 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98819b7bfdca1b66f9a1e733cb86f851c1fc8fae5776746fad283020d90cb2ec
-  data.tar.gz: 88f929dd51fa6804f022a607f5767f11c241759c7939f2c788198f27edd9b36c
+  metadata.gz: 2131a7723ecf3fde157b22ad8d84d9a03b7703fd30cb439719235047424aaded
+  data.tar.gz: a09642a35676ba55d866b1e813a0e4162b895131703166e77bd4c539d5c572ef
 SHA512:
-  metadata.gz: 5ad1de21bc0adc67b0e37d301ca667e9f075f0405451c35c7b91323f4abbbe18644ced47badef177a191f6a1a5828d5277e863d50a3f94af9c4198a9d6bfdc05
-  data.tar.gz: 10b14f7be24aa84b9b27c96707cd836b746fd132b83c0ee8344dc42c7dd98b56f25b63d9d9275809d2cc55d33e3ca9c0d40dd893db6b5bd57332b48ff3072764
+  metadata.gz: 10270ffcd3f415d9aa38feda85cba120037249a6997beca140b01dbd632b8a1622851ac305d2a812090e9d4a785c547f71523f88e327d4975d153ba337584c55
+  data.tar.gz: 961802b3a00cb62b843a93316aefdf29b56c44b582f75bbafee82d5fd8db4a18c6a5557f1248a1bcbf881cc1983138de2a4476b02ec140adae6716f64afca9e5

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## v0.8.0 — 2026-11-03
+
+- Built on the zzq 0.6 crates. Bind and connect errors name the endpoint
+  as given: a `tls://`, `ws://` or `wss://` bind no longer says `tcp://`,
+  and an IPv6 host keeps its brackets.
+
 ## v0.7.0 — 2026-10-31
 
 - Built on the zzq 0.5 crates, with their fixes. With `data_dir:`, a QoS 2

data/ext/zzq_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zzq_native"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2024"
 rust-version = "1.93"
 license = "ISC OR Apache-2.0"
@@ -12,8 +12,8 @@ name = "zzq_native"
 crate-type = ["cdylib"]
 
 [dependencies]
-zzq-broker = "0.5"
-zzq-client = "0.5"
+zzq-broker = "0.6"
+zzq-client = "0.6"
 bytes = "1.12"
 libc = "0.2"
 rb-sys = "0.9"

data/ext/zzq_native/src/broker.rs

@@ -1,6 +1,6 @@
 //! `ZZQ::Native::Broker`: a running broker.
 
-use std::sync::{Arc, OnceLock};
+use std::sync::Arc;
 
 use rb_sys::VALUE;
 use tokio::sync::{OwnedRwLockReadGuard, RwLock};
@@ -11,8 +11,7 @@ use crate::op::{self, Out};
 use crate::rb::{self, DataType, RbResult, RubyErr};
 use crate::{context, options};
 
-static TYPE: DataType = DataType::new::<NativeBroker>(c"ZZQ::Native::Broker");
-static CLASS: OnceLock<usize> = OnceLock::new();
+static TYPE: DataType<NativeBroker> = DataType::new(c"ZZQ::Native::Broker");
 
 #[derive(Debug)]
 struct NativeBroker {
@@ -26,7 +25,7 @@ type Held = OwnedRwLockReadGuard<Option<Broker>, Broker>;
 
 /// The broker for one call, or `Closed` once a shutdown has begun.
 fn get(value: VALUE) -> RbResult<Held> {
-    let native: &NativeBroker = unsafe { TYPE.get(value) }?;
+    let native: &NativeBroker = TYPE.get(value)?;
     native
         .broker
         .clone()
@@ -41,7 +40,7 @@ pub fn wrap(b: Broker) -> RbResult<VALUE> {
     let native = NativeBroker {
         broker: Arc::new(RwLock::new(Some(b))),
     };
-    TYPE.wrap(*CLASS.get().expect("registered") as VALUE, native)
+    TYPE.wrap(native)
 }
 
 pub fn stats_hash(s: &Stats) -> RbResult<VALUE> {
@@ -115,7 +114,7 @@ fn stats(this: VALUE) -> RbResult<VALUE> {
 /// An op that waits for the calls using the broker to finish, then shuts
 /// it down.
 fn shutdown(this: VALUE) -> RbResult<VALUE> {
-    let native: &NativeBroker = unsafe { TYPE.get(this) }?;
+    let native: &NativeBroker = TYPE.get(this)?;
     let broker = native.broker.clone();
     op::new(async move {
         let Some(b) = broker.write_owned().await.take() else {
@@ -126,39 +125,14 @@ fn shutdown(this: VALUE) -> RbResult<VALUE> {
     })
 }
 
-unsafe extern "C" fn broker_start(_class: VALUE, opts: VALUE) -> VALUE {
-    rb::wrap(|| start(opts))
-}
-
-unsafe extern "C" fn broker_bind(this: VALUE, uri: VALUE) -> VALUE {
-    rb::wrap(|| bind(this, uri))
-}
-
-unsafe extern "C" fn broker_publish(
-    this: VALUE,
-    topic: VALUE,
-    payload: VALUE,
-    qos: VALUE,
-    retain: VALUE,
-) -> VALUE {
-    rb::wrap(|| publish(this, topic, payload, qos, retain))
-}
-
-unsafe extern "C" fn broker_stats(this: VALUE) -> VALUE {
-    rb::wrap(|| stats(this))
-}
-
-unsafe extern "C" fn broker_shutdown(this: VALUE) -> VALUE {
-    rb::wrap(|| shutdown(this))
-}
-
 pub fn register(native: VALUE) -> RbResult<()> {
-    let class = rb::define_class_under(native, c"Broker")?;
-    let _ = CLASS.set(class as usize);
-    rb::define_singleton_method(class, c"start", broker_start as *const (), 1)?;
-    rb::define_method(class, c"bind", broker_bind as *const (), 1)?;
-    rb::define_method(class, c"publish", broker_publish as *const (), 4)?;
-    rb::define_method(class, c"stats", broker_stats as *const (), 0)?;
-    rb::define_method(class, c"shutdown", broker_shutdown as *const (), 0)?;
+    let class = TYPE.register(native, c"Broker")?;
+    rb::singleton!(class, c"start", |_class, opts| start(opts))?;
+    rb::method!(class, c"bind", |this, uri| bind(this, uri))?;
+    rb::method!(class, c"publish", |this, topic, payload, qos, retain| {
+        publish(this, topic, payload, qos, retain)
+    })?;
+    rb::method!(class, c"stats", |this| stats(this))?;
+    rb::method!(class, c"shutdown", |this| shutdown(this))?;
     Ok(())
 }

data/ext/zzq_native/src/client.rs

@@ -18,8 +18,7 @@ use crate::op::{self, Out};
 use crate::rb::{self, DataType, RbResult, RubyErr};
 use crate::{context, options, wake};
 
-static TYPE: DataType = DataType::new::<NativeClient>(c"ZZQ::Native::Client");
-static CLASS: OnceLock<usize> = OnceLock::new();
+static TYPE: DataType<NativeClient> = DataType::new(c"ZZQ::Native::Client");
 /// `ZZQ::Message` and a frozen empty Array for messages without
 /// Subscription Identifiers.
 static MESSAGE: OnceLock<(usize, usize)> = OnceLock::new();
@@ -44,7 +43,7 @@ impl std::fmt::Debug for NativeClient {
 }
 
 fn get(value: VALUE) -> RbResult<&'static NativeClient> {
-    unsafe { TYPE.get(value) }
+    TYPE.get(value)
 }
 
 /// A Ruby object for a connected client.
@@ -57,7 +56,7 @@ pub fn wrap(c: Client) -> RbResult<VALUE> {
         client: Arc::new(tokio::sync::Mutex::new(c)),
         recv: Mutex::new(None),
     };
-    TYPE.wrap(*CLASS.get().expect("registered") as VALUE, native)
+    TYPE.wrap(native)
 }
 
 fn connect(uri: VALUE, opts: VALUE) -> RbResult<VALUE> {
@@ -223,72 +222,37 @@ fn disconnect(this: VALUE, reason: VALUE) -> RbResult<VALUE> {
     })
 }
 
-unsafe extern "C" fn client_connect(_class: VALUE, uri: VALUE, opts: VALUE) -> VALUE {
-    rb::wrap(|| connect(uri, opts))
-}
-
-unsafe extern "C" fn client_publish(
-    this: VALUE,
-    topic: VALUE,
-    payload: VALUE,
-    qos: VALUE,
-    retain: VALUE,
-) -> VALUE {
-    rb::wrap(|| publish(this, topic, payload, qos, retain))
-}
-
-unsafe extern "C" fn client_subscribe(this: VALUE, filters: VALUE, sub_id: VALUE) -> VALUE {
-    rb::wrap(|| subscribe(this, filters, sub_id))
-}
-
-unsafe extern "C" fn client_unsubscribe(this: VALUE, filters: VALUE) -> VALUE {
-    rb::wrap(|| unsubscribe(this, filters))
-}
-
-unsafe extern "C" fn client_receive(this: VALUE, wake: VALUE, max: VALUE) -> VALUE {
-    rb::wrap(|| receive(this, wake, max))
-}
-
-unsafe extern "C" fn client_disconnect(this: VALUE, reason: VALUE) -> VALUE {
-    rb::wrap(|| disconnect(this, reason))
-}
-
-unsafe extern "C" fn client_session_present(this: VALUE) -> VALUE {
-    rb::wrap(|| Ok(rb::bool_value(get(this)?.session_present)))
-}
-
-unsafe extern "C" fn client_assigned_client_id(this: VALUE) -> VALUE {
-    rb::wrap(|| match &get(this)?.assigned_client_id {
-        Some(id) => rb::new_utf8_string(id),
-        None => Ok(rb::qnil()),
-    })
-}
-
 pub fn register(zzq: VALUE, native: VALUE) -> RbResult<()> {
     let message = rb::const_get(zzq, c"Message")?;
     let no_ids = rb::freeze(rb::array_new_capa(0)?);
     rb::define_const(native, c"NO_SUBSCRIPTION_IDS", no_ids)?;
     let _ = MESSAGE.set((message as usize, no_ids as usize));
 
-    let class = rb::define_class_under(native, c"Client")?;
-    let _ = CLASS.set(class as usize);
-    rb::define_singleton_method(class, c"connect", client_connect as *const (), 2)?;
-    rb::define_method(class, c"publish", client_publish as *const (), 4)?;
-    rb::define_method(class, c"subscribe", client_subscribe as *const (), 2)?;
-    rb::define_method(class, c"unsubscribe", client_unsubscribe as *const (), 1)?;
-    rb::define_method(class, c"receive", client_receive as *const (), 2)?;
-    rb::define_method(class, c"disconnect", client_disconnect as *const (), 1)?;
-    rb::define_method(
-        class,
-        c"session_present?",
-        client_session_present as *const (),
-        0,
-    )?;
-    rb::define_method(
-        class,
-        c"assigned_client_id",
-        client_assigned_client_id as *const (),
-        0,
-    )?;
+    let class = TYPE.register(native, c"Client")?;
+    rb::singleton!(class, c"connect", |_class, uri, opts| connect(uri, opts))?;
+    rb::method!(class, c"publish", |this, topic, payload, qos, retain| {
+        publish(this, topic, payload, qos, retain)
+    })?;
+    rb::method!(class, c"subscribe", |this, filters, sub_id| {
+        subscribe(this, filters, sub_id)
+    })?;
+    rb::method!(class, c"unsubscribe", |this, filters| unsubscribe(
+        this, filters
+    ))?;
+    rb::method!(class, c"receive", |this, wake, max| receive(
+        this, wake, max
+    ))?;
+    rb::method!(class, c"disconnect", |this, reason| disconnect(
+        this, reason
+    ))?;
+    rb::method!(class, c"session_present?", |this| {
+        Ok(rb::bool_value(get(this)?.session_present))
+    })?;
+    rb::method!(class, c"assigned_client_id", |this| {
+        match &get(this)?.assigned_client_id {
+            Some(id) => rb::new_utf8_string(id),
+            None => Ok(rb::qnil()),
+        }
+    })?;
     Ok(())
 }

data/ext/zzq_native/src/lib.rs

@@ -9,27 +9,8 @@ mod options;
 mod rb;
 mod wake;
 
-use rb_sys::VALUE;
-
 use crate::rb::RbResult;
 
-unsafe extern "C" fn io_threads(_module: VALUE) -> VALUE {
-    rb::wrap(|| Ok(rb::u64_value(context::io_threads() as u64)))
-}
-
-unsafe extern "C" fn set_io_threads(_module: VALUE, n: VALUE) -> VALUE {
-    rb::wrap(|| {
-        let n = usize::try_from(rb::value_to_i64(n)?)
-            .map_err(|_| rb::RubyErr::arg("io_threads must be positive"))?;
-        if !context::set_io_threads(n) {
-            return Err(error::zzq(
-                "set io_threads before the first client or broker",
-            ));
-        }
-        Ok(rb::qnil())
-    })
-}
-
 /// Called once by Ruby when it loads the extension.
 #[unsafe(no_mangle)]
 pub extern "C" fn Init_zzq_native() {
@@ -42,8 +23,19 @@ fn init() -> RbResult<()> {
     let zzq = rb::define_module(c"ZZQ")?;
     let native = rb::define_module_under(zzq, c"Native")?;
     error::init(zzq)?;
-    rb::define_singleton_method(native, c"io_threads", io_threads as *const (), 0)?;
-    rb::define_singleton_method(native, c"io_threads=", set_io_threads as *const (), 1)?;
+    rb::singleton!(native, c"io_threads", |_module| {
+        Ok(rb::u64_value(context::io_threads() as u64))
+    })?;
+    rb::singleton!(native, c"io_threads=", |_module, n| {
+        let n = usize::try_from(rb::value_to_i64(n)?)
+            .map_err(|_| rb::RubyErr::arg("io_threads must be positive"))?;
+        if !context::set_io_threads(n) {
+            return Err(error::zzq(
+                "set io_threads before the first client or broker",
+            ));
+        }
+        Ok(rb::qnil())
+    })?;
     wake::register(native)?;
     op::register(native)?;
     client::register(zzq, native)?;

data/ext/zzq_native/src/op.rs

@@ -14,8 +14,7 @@ use crate::error::Error;
 use crate::rb::{self, DataType, RbResult};
 use crate::{broker, client, wake};
 
-static TYPE: DataType = DataType::new::<Op>(c"ZZQ::Native::Op");
-static CLASS: OnceLock<usize> = OnceLock::new();
+static TYPE: DataType<Op> = DataType::new(c"ZZQ::Native::Op");
 static PENDING: OnceLock<usize> = OnceLock::new();
 
 /// What a finished op returns to Ruby.
@@ -65,11 +64,11 @@ fn wrap(task: Task) -> RbResult<VALUE> {
     let op = Op {
         task: Mutex::new(Some(task)),
     };
-    TYPE.wrap(*CLASS.get().expect("registered") as VALUE, op)
+    TYPE.wrap(op)
 }
 
 fn get(value: VALUE) -> RbResult<&'static Op> {
-    unsafe { TYPE.get(value) }
+    TYPE.get(value)
 }
 
 fn poll(this: VALUE, wake: VALUE) -> RbResult<VALUE> {
@@ -109,12 +108,10 @@ fn to_ruby(out: Out) -> RbResult<VALUE> {
     }
 }
 
-unsafe extern "C" fn op_poll(this: VALUE, wake: VALUE) -> VALUE {
-    rb::wrap(|| poll(this, wake))
-}
-
-unsafe extern "C" fn op_cancel(this: VALUE) -> VALUE {
-    rb::wrap(|| {
+pub fn register(native: VALUE) -> RbResult<()> {
+    let class = TYPE.register(native, c"Op")?;
+    rb::method!(class, c"poll", |this, wake| poll(this, wake))?;
+    rb::method!(class, c"cancel", |this| {
         let task = get(this)?
             .task
             .lock()
@@ -122,14 +119,7 @@ unsafe extern "C" fn op_cancel(this: VALUE) -> VALUE {
             .take();
         drop(task);
         Ok(rb::qnil())
-    })
-}
-
-pub fn register(native: VALUE) -> RbResult<()> {
-    let class = rb::define_class_under(native, c"Op")?;
-    let _ = CLASS.set(class as usize);
-    rb::define_method(class, c"poll", op_poll as *const (), 1)?;
-    rb::define_method(class, c"cancel", op_cancel as *const (), 0)?;
+    })?;
     let pending = rb::freeze(rb::protect(|| unsafe {
         rb_sys::rb_obj_alloc(rb_sys::rb_cObject)
     })?);

data/ext/zzq_native/src/rb.rs

@@ -2,8 +2,10 @@
 //! `rb_protect`, so a Ruby exception never unwinds through Rust frames.
 
 use std::ffi::{CStr, CString, c_char, c_long, c_void};
+use std::marker::PhantomData;
 use std::panic::{AssertUnwindSafe, catch_unwind};
 use std::ptr;
+use std::sync::OnceLock;
 
 use rb_sys::{VALUE, rb_data_type_struct__bindgen_ty_1, rb_data_type_t, size_t};
 
@@ -310,47 +312,67 @@ pub fn const_get(module: VALUE, name: &CStr) -> RbResult<VALUE> {
     protect(|| unsafe { rb_sys::rb_const_get(module, rb_sys::rb_intern(name.as_ptr())) })
 }
 
-/// A Ruby type for a boxed `T`, which GC frees with the object.
-pub struct DataType(rb_data_type_t);
-
-unsafe impl Send for DataType {}
-unsafe impl Sync for DataType {}
-
-impl DataType {
-    pub const fn new<T>(name: &'static CStr) -> Self {
-        DataType(rb_data_type_t {
-            wrap_struct_name: name.as_ptr(),
-            function: rb_data_type_struct__bindgen_ty_1 {
-                dmark: None,
-                dfree: Some(free_box::<T>),
-                dsize: Some(size_box::<T>),
-                dcompact: None,
-                reserved: [ptr::null_mut(); 1],
+/// A Ruby class whose objects each hold a boxed `T`, which GC frees with
+/// the object.
+pub struct DataType<T> {
+    raw: rb_data_type_t,
+    /// The class, once [`DataType::register`] defined it.
+    class: OnceLock<usize>,
+    _value: PhantomData<fn() -> T>,
+}
+
+// SAFETY: the raw type holds only pointers to statics and functions,
+// which Ruby reads and nothing writes.
+unsafe impl<T> Send for DataType<T> {}
+unsafe impl<T> Sync for DataType<T> {}
+
+impl<T> DataType<T> {
+    pub const fn new(name: &'static CStr) -> Self {
+        DataType {
+            raw: rb_data_type_t {
+                wrap_struct_name: name.as_ptr(),
+                function: rb_data_type_struct__bindgen_ty_1 {
+                    dmark: None,
+                    dfree: Some(free_box::<T>),
+                    dsize: Some(size_box::<T>),
+                    dcompact: None,
+                    reserved: [ptr::null_mut(); 1],
+                },
+                parent: ptr::null(),
+                data: ptr::null_mut(),
+                // RUBY_TYPED_FREE_IMMEDIATELY: dropping never blocks or calls Ruby.
+                flags: 1,
             },
-            parent: ptr::null(),
-            data: ptr::null_mut(),
-            // RUBY_TYPED_FREE_IMMEDIATELY: dropping never blocks or calls Ruby.
-            flags: 1,
-        })
+            class: OnceLock::new(),
+            _value: PhantomData,
+        }
     }
 
     const fn ptr(&'static self) -> *const rb_data_type_t {
-        &raw const self.0
+        &raw const self.raw
+    }
+
+    /// Defines the class, `name` under `outer`, whose objects hold a `T`.
+    pub fn register(&'static self, outer: VALUE, name: &CStr) -> RbResult<VALUE> {
+        let class = define_class_under(outer, name)?;
+        let _ = self.class.set(class as usize);
+        Ok(class)
     }
 
-    /// Wraps `value` in a new object of `class`.
-    pub fn wrap<T>(&'static self, class: VALUE, value: T) -> RbResult<VALUE> {
+    /// Wraps `value` in a new object of the class.
+    pub fn wrap(&'static self, value: T) -> RbResult<VALUE> {
+        let class = *self
+            .class
+            .get()
+            .ok_or_else(|| RubyErr::runtime("native class not registered"))?
+            as VALUE;
         let raw = Box::into_raw(Box::new(value));
         protect(|| unsafe { rb_sys::rb_data_typed_object_wrap(class, raw.cast(), self.ptr()) })
             .inspect_err(|_| drop(unsafe { Box::from_raw(raw) }))
     }
 
-    /// The `T` inside `value`.
-    ///
-    /// # Safety
-    ///
-    /// `T` must be the type this data type was made for.
-    pub unsafe fn get<T>(&'static self, value: VALUE) -> RbResult<&'static T> {
+    /// The `T` inside `value`, which must be an object of the class.
+    pub fn get(&'static self, value: VALUE) -> RbResult<&'static T> {
         let mut ptr = ptr::null_mut();
         protect(|| unsafe {
             ptr = rb_sys::rb_check_typeddata(value, self.ptr());
@@ -359,6 +381,8 @@ impl DataType {
         if ptr.is_null() {
             return Err(RubyErr::runtime("native object is empty"));
         }
+        // SAFETY: Ruby checked that `value` has this data type, whose
+        // objects hold a boxed `T` that lives as long as the object.
         Ok(unsafe { &*ptr.cast::<T>() })
     }
 }
@@ -403,27 +427,60 @@ pub fn define_const(module: VALUE, name: &CStr, value: VALUE) -> RbResult<()> {
     Ok(())
 }
 
-/// A method with `arity` arguments. `func` takes `self` and then each
-/// argument as a `VALUE`.
-pub fn define_method(class: VALUE, name: &CStr, func: *const (), arity: i32) -> RbResult<()> {
-    let func = unsafe { std::mem::transmute::<*const (), unsafe extern "C" fn() -> VALUE>(func) };
-    protect(|| unsafe {
-        rb_sys::rb_define_method(class, name.as_ptr(), Some(func), arity);
-        qnil()
-    })?;
-    Ok(())
+/// Defines method `$name` of `$class`, which runs `$body` with the
+/// receiver as `$this` and each argument as a `VALUE`. The macro writes
+/// the C function and counts its arguments, so Ruby's arity matches it.
+macro_rules! method {
+    ($class:expr, $name:expr, |$this:ident $(, $arg:ident)*| $body:expr) => {{
+        unsafe extern "C" fn shim(
+            $this: ::rb_sys::VALUE $(, $arg: ::rb_sys::VALUE)*
+        ) -> ::rb_sys::VALUE {
+            $crate::rb::wrap(|| $body)
+        }
+        let arity = 0 $(+ $crate::rb::one(stringify!($arg)))*;
+        $crate::rb::define(false, $class, $name, shim as *const (), arity)
+    }};
+}
+
+/// [`method!`] on the singleton class: `$this` is the class or module.
+macro_rules! singleton {
+    ($object:expr, $name:expr, |$this:ident $(, $arg:ident)*| $body:expr) => {{
+        unsafe extern "C" fn shim(
+            $this: ::rb_sys::VALUE $(, $arg: ::rb_sys::VALUE)*
+        ) -> ::rb_sys::VALUE {
+            $crate::rb::wrap(|| $body)
+        }
+        let arity = 0 $(+ $crate::rb::one(stringify!($arg)))*;
+        $crate::rb::define(true, $object, $name, shim as *const (), arity)
+    }};
+}
+
+pub(crate) use {method, singleton};
+
+/// One argument, for the arity [`method!`] counts.
+pub const fn one(_: &str) -> i32 {
+    1
 }
 
-/// A singleton method, as [`define_method`].
-pub fn define_singleton_method(
+/// Defines `func`, a C function of `arity` arguments after the receiver,
+/// as a method of `object`, or of its singleton class. Only [`method!`]
+/// and [`singleton!`] call it, with a `func` they made for that arity.
+pub fn define(
+    singleton: bool,
     object: VALUE,
     name: &CStr,
     func: *const (),
     arity: i32,
 ) -> RbResult<()> {
+    // SAFETY: Ruby calls `func` with the receiver and `arity` VALUEs,
+    // the parameters `method!` gave it.
     let func = unsafe { std::mem::transmute::<*const (), unsafe extern "C" fn() -> VALUE>(func) };
     protect(|| unsafe {
-        rb_sys::rb_define_singleton_method(object, name.as_ptr(), Some(func), arity);
+        if singleton {
+            rb_sys::rb_define_singleton_method(object, name.as_ptr(), Some(func), arity);
+        } else {
+            rb_sys::rb_define_method(object, name.as_ptr(), Some(func), arity);
+        }
         qnil()
     })?;
     Ok(())

data/ext/zzq_native/src/wake.rs

@@ -16,8 +16,7 @@ use rb_sys::VALUE;
 
 use crate::rb::{self, DataType, RbResult, RubyErr};
 
-static TYPE: DataType = DataType::new::<Wake>(c"ZZQ::Native::Wake");
-static CLASS: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
+static TYPE: DataType<Wake> = DataType::new(c"ZZQ::Native::Wake");
 
 /// A pipe one fiber waits on.
 #[derive(Debug)]
@@ -124,32 +123,21 @@ unsafe fn pipe(fds: &mut [RawFd; 2]) -> i32 {
 
 /// The `Wake` inside `value`.
 pub fn get(value: VALUE) -> RbResult<&'static Wake> {
-    unsafe { TYPE.get(value) }
+    TYPE.get(value)
 }
 
-unsafe extern "C" fn wake_new(_class: VALUE) -> VALUE {
-    rb::wrap(|| {
+pub fn register(native: VALUE) -> RbResult<()> {
+    let class = TYPE.register(native, c"Wake")?;
+    rb::singleton!(class, c"new", |_class| {
         let wake = Wake::new().map_err(|e| RubyErr::runtime(format!("pipe failed: {e}")))?;
-        TYPE.wrap(*CLASS.get().expect("registered") as VALUE, wake)
-    })
-}
-
-unsafe extern "C" fn wake_fd(this: VALUE) -> VALUE {
-    rb::wrap(|| Ok(rb::u64_value(get(this)?.pipe.read_fd as u64)))
-}
-
-unsafe extern "C" fn wake_clear(this: VALUE) -> VALUE {
-    rb::wrap(|| {
+        TYPE.wrap(wake)
+    })?;
+    rb::method!(class, c"fd", |this| Ok(rb::u64_value(
+        get(this)?.pipe.read_fd as u64
+    )))?;
+    rb::method!(class, c"clear", |this| {
         get(this)?.clear();
         Ok(rb::qnil())
-    })
-}
-
-pub fn register(native: VALUE) -> RbResult<()> {
-    let class = rb::define_class_under(native, c"Wake")?;
-    let _ = CLASS.set(class as usize);
-    rb::define_singleton_method(class, c"new", wake_new as *const (), 0)?;
-    rb::define_method(class, c"fd", wake_fd as *const (), 0)?;
-    rb::define_method(class, c"clear", wake_clear as *const (), 0)?;
+    })?;
     Ok(())
 }

data/lib/zzq/version.rb

@@ -2,5 +2,5 @@
 
 module ZZQ
   # Gem version.
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zzq
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Patrik Wenger