prosody 0.5.1 → 0.6.0

data/ext/prosody/src/handler/state/query.rs

@@ -0,0 +1,264 @@
+//! Translation of Ruby query keywords into core query settings.
+//!
+//! Map and set queries select string keys. Deque queries select positions that
+//! count from the front. Every option narrows the selection, and `nil` leaves
+//! an option unset. `from`, `after`, `to`, and `before` apply in iteration
+//! order, so a reverse query starts at the high end. `range` bounds keys or
+//! positions in ascending terms and applies in either direction.
+//!
+//! A bad option raises `ArgumentError` or `TypeError`, as Ruby does for a bad
+//! keyword argument.
+
+use super::transient_state_error;
+use magnus::r_hash::ForEach;
+use magnus::value::ReprValue;
+use magnus::{Error, Integer, RHash, Range, Ruby, StaticSymbol, Symbol, TryConvert, Value};
+use prosody::state::{DequeQuery, Direction, ErasedKeyQuery};
+use std::num::NonZeroUsize;
+use std::ops::Bound;
+
+/// Raw option values from a Ruby keyword hash. `nil` values are absent.
+#[derive(Default)]
+struct Keywords {
+    from: Option<Value>,
+    after: Option<Value>,
+    to: Option<Value>,
+    before: Option<Value>,
+    range: Option<Value>,
+    prefix: Option<Value>,
+    limit: Option<Value>,
+}
+
+/// Translated edges and limit. `T` is a key or a position.
+///
+/// `start` and `end` are in iteration order. `range` is in ascending terms.
+struct Bounds<T> {
+    start: Bound<T>,
+    end: Bound<T>,
+    range: Option<(Bound<T>, Bound<T>)>,
+    limit: Option<NonZeroUsize>,
+}
+
+impl Keywords {
+    /// Collects the keyword hash. Deques have no `prefix`.
+    fn collect(ruby: &Ruby, options: RHash, prefix_allowed: bool) -> Result<Self, Error> {
+        let mut keywords = Self::default();
+        options.foreach(|keyword: Symbol, value: Value| {
+            let name = keyword.name()?;
+            let slot = match name.as_ref() {
+                "from" => &mut keywords.from,
+                "after" => &mut keywords.after,
+                "to" => &mut keywords.to,
+                "before" => &mut keywords.before,
+                "range" => &mut keywords.range,
+                "prefix" if prefix_allowed => &mut keywords.prefix,
+                "limit" => &mut keywords.limit,
+                other => return Err(argument_error(ruby, format!("unknown keyword: :{other}"))),
+            };
+            *slot = (!value.is_nil()).then_some(value);
+            Ok(ForEach::Continue)
+        })?;
+        Ok(keywords)
+    }
+
+    /// Translates the edges, range, and limit with `convert`.
+    fn bounds<T, F>(self, ruby: &Ruby, convert: F) -> Result<Bounds<T>, Error>
+    where
+        F: Fn(&'static str, Value) -> Result<T, Error>,
+    {
+        let start = edge(ruby, ("from", self.from), ("after", self.after), &convert)?;
+        let end = edge(ruby, ("to", self.to), ("before", self.before), &convert)?;
+        let range = self
+            .range
+            .map(|value| range(ruby, value, &convert))
+            .transpose()?;
+        let limit = self.limit.map(|value| limit(ruby, value)).transpose()?;
+        Ok(Bounds {
+            start,
+            end,
+            range,
+            limit,
+        })
+    }
+}
+
+/// Builds a map or set query from a direction token and keywords.
+///
+/// # Errors
+///
+/// Raises `ArgumentError` for an unknown keyword, both edges of one side, or a
+/// limit that is not a positive `Integer`. Raises
+/// `TypeError` for a key that is not a `String` or a range that is not a
+/// `Range`. An invalid direction token raises a transient state error.
+pub(crate) fn key_query(
+    ruby: &Ruby,
+    direction: StaticSymbol,
+    options: RHash,
+) -> Result<ErasedKeyQuery, Error> {
+    let query = ErasedKeyQuery::new().direction(parse_direction(ruby, direction)?);
+    let keywords = Keywords::collect(ruby, options, true)?;
+    let prefix = keywords.prefix.map(String::try_convert).transpose()?;
+    let bounds = keywords.bounds(ruby, |_, value| String::try_convert(value))?;
+
+    let mut query = match bounds.start {
+        Bound::Included(key) => query.from(key),
+        Bound::Excluded(key) => query.after(key),
+        Bound::Unbounded => query,
+    };
+    query = match bounds.end {
+        Bound::Included(key) => query.to(key),
+        Bound::Excluded(key) => query.before(key),
+        Bound::Unbounded => query,
+    };
+    if let Some(range) = bounds.range {
+        query = query.range(range);
+    }
+    if let Some(prefix) = prefix {
+        query = query.prefix(prefix);
+    }
+    if let Some(limit) = bounds.limit {
+        query = query.limit(limit);
+    }
+    Ok(query)
+}
+
+/// Builds a deque query from a direction token and keywords.
+///
+/// Positions count from the front and must be non-negative. Use a reverse
+/// traversal to read from the back.
+///
+/// # Errors
+///
+/// Raises `ArgumentError` for an unknown keyword, both edges of one side, a
+/// position that is not a non-negative `Integer`, or a limit that is not a
+/// positive `Integer`. Raises `TypeError` for a range that
+/// is not a `Range`.
+pub(crate) fn position_query(
+    ruby: &Ruby,
+    direction: StaticSymbol,
+    options: RHash,
+) -> Result<DequeQuery, Error> {
+    let query = DequeQuery::new().direction(parse_direction(ruby, direction)?);
+    let bounds = Keywords::collect(ruby, options, false)?
+        .bounds(ruby, |keyword, value| position(ruby, keyword, value))?;
+
+    let mut query = match bounds.start {
+        Bound::Included(position) => query.from(position),
+        Bound::Excluded(position) => query.after(position),
+        Bound::Unbounded => query,
+    };
+    query = match bounds.end {
+        Bound::Included(position) => query.to(position),
+        Bound::Excluded(position) => query.before(position),
+        Bound::Unbounded => query,
+    };
+    if let Some(range) = bounds.range {
+        query = query.range(range);
+    }
+    if let Some(limit) = bounds.limit {
+        query = query.limit(limit);
+    }
+    Ok(query)
+}
+
+/// Parses a traversal direction token into the core [`Direction`].
+///
+/// An invalid token is a caller mistake and rejects transient.
+fn parse_direction(ruby: &Ruby, direction: StaticSymbol) -> Result<Direction, Error> {
+    match direction.name()? {
+        "forward" => Ok(Direction::Forward),
+        "backward" => Ok(Direction::Backward),
+        other => Err(transient_state_error(
+            ruby,
+            format!("direction: expected :forward or :backward, got :{other}"),
+        )),
+    }
+}
+
+/// Translates one side of the selection. The inclusive and exclusive edges of
+/// one side are exclusive: an options hash has no call order to pick one.
+fn edge<T, F>(
+    ruby: &Ruby,
+    (inclusive_name, inclusive): (&'static str, Option<Value>),
+    (exclusive_name, exclusive): (&'static str, Option<Value>),
+    convert: &F,
+) -> Result<Bound<T>, Error>
+where
+    F: Fn(&'static str, Value) -> Result<T, Error>,
+{
+    match (inclusive, exclusive) {
+        (Some(_), Some(_)) => Err(argument_error(
+            ruby,
+            format!("{inclusive_name}: and {exclusive_name}: are exclusive; pass one of them"),
+        )),
+        (Some(value), None) => Ok(Bound::Included(convert(inclusive_name, value)?)),
+        (None, Some(value)) => Ok(Bound::Excluded(convert(exclusive_name, value)?)),
+        (None, None) => Ok(Bound::Unbounded),
+    }
+}
+
+/// Translates a Ruby `Range`. A `nil` end is unbounded. An exclusive range
+/// excludes its end. A descending range is a valid empty range, so it selects
+/// nothing.
+fn range<T, F>(ruby: &Ruby, value: Value, convert: &F) -> Result<(Bound<T>, Bound<T>), Error>
+where
+    F: Fn(&'static str, Value) -> Result<T, Error>,
+{
+    let Some(range) = Range::from_value(value) else {
+        return Err(Error::new(
+            ruby.exception_type_error(),
+            format!("range: expected a Range, got {}", value.inspect()),
+        ));
+    };
+
+    let low: Value = range.beg()?;
+    let low = if low.is_nil() {
+        Bound::Unbounded
+    } else {
+        Bound::Included(convert("range", low)?)
+    };
+    let high: Value = range.end()?;
+    let high = match (high.is_nil(), range.excl()) {
+        (true, _) => Bound::Unbounded,
+        (false, true) => Bound::Excluded(convert("range", high)?),
+        (false, false) => Bound::Included(convert("range", high)?),
+    };
+
+    Ok((low, high))
+}
+
+/// Translates a front-relative deque position.
+fn position(ruby: &Ruby, keyword: &'static str, value: Value) -> Result<usize, Error> {
+    let invalid = || {
+        argument_error(
+            ruby,
+            format!(
+                "{keyword}: expected a non-negative Integer position, got {}",
+                value.inspect()
+            ),
+        )
+    };
+    let integer = Integer::from_value(value).ok_or_else(invalid)?;
+    integer.to_usize().map_err(|_| invalid())
+}
+
+/// Translates a result limit. It keeps its own Integer check: a helper shared
+/// with `position` saves no lines.
+fn limit(ruby: &Ruby, value: Value) -> Result<NonZeroUsize, Error> {
+    let invalid = || {
+        argument_error(
+            ruby,
+            format!(
+                "limit: expected a positive Integer, got {}",
+                value.inspect()
+            ),
+        )
+    };
+    let integer = Integer::from_value(value).ok_or_else(invalid)?;
+    let limit = integer.to_usize().map_err(|_| invalid())?;
+    NonZeroUsize::new(limit).ok_or_else(invalid)
+}
+
+fn argument_error(ruby: &Ruby, message: String) -> Error {
+    Error::new(ruby.exception_arg_error(), message)
+}

data/ext/prosody/src/handler/state/registration.rs

@@ -3,67 +3,10 @@
 use super::{
     NativeJsonDequeScan, NativeJsonDequeState, NativeJsonMapScan, NativeJsonMapState,
     NativeJsonValueState, NativeMapKeyScan, NativeMessageDequeScan, NativeMessageDequeState,
-    NativeMessageMapScan, NativeMessageMapState, NativeMessageValueState,
+    NativeMessageMapScan, NativeMessageMapState, NativeMessageValueState, NativeSetState,
 };
-use crate::{ROOT_MOD, id};
-use magnus::{Error, Module, Ruby, method};
-
-macro_rules! register_value {
-    ($ruby:expr, $module:expr, $name:literal, $type:ty) => {{
-        let class = $module.define_class(id!($ruby, $name), $ruby.class_object())?;
-        class.define_method(id!($ruby, "get"), method!(<$type>::get, 0))?;
-        class.define_method(id!($ruby, "set"), method!(<$type>::set, 1))?;
-        class.define_method(id!($ruby, "clear"), method!(<$type>::clear, 0))?;
-        class.define_method(id!($ruby, "commit"), method!(<$type>::commit, 0))?;
-        class.define_method(id!($ruby, "rollback"), method!(<$type>::rollback, 0))?;
-    }};
-}
-
-macro_rules! register_map {
-    ($ruby:expr, $module:expr, $name:literal, $type:ty) => {{
-        let class = $module.define_class(id!($ruby, $name), $ruby.class_object())?;
-        class.define_method(id!($ruby, "get"), method!(<$type>::get, 1))?;
-        class.define_method(
-            id!($ruby, "contains_key"),
-            method!(<$type>::contains_key, 1),
-        )?;
-        class.define_method(id!($ruby, "get_many"), method!(<$type>::get_many, 1))?;
-        class.define_method(id!($ruby, "set"), method!(<$type>::set, 2))?;
-        class.define_method(id!($ruby, "remove"), method!(<$type>::remove, 1))?;
-        class.define_method(id!($ruby, "clear"), method!(<$type>::clear, 0))?;
-        class.define_method(id!($ruby, "scan"), method!(<$type>::scan, 1))?;
-        class.define_method(id!($ruby, "keys"), method!(<$type>::keys, 1))?;
-        class.define_method(id!($ruby, "commit"), method!(<$type>::commit, 0))?;
-        class.define_method(id!($ruby, "rollback"), method!(<$type>::rollback, 0))?;
-    }};
-}
-
-macro_rules! register_deque {
-    ($ruby:expr, $module:expr, $name:literal, $type:ty) => {{
-        let class = $module.define_class(id!($ruby, $name), $ruby.class_object())?;
-        class.define_method(id!($ruby, "len"), method!(<$type>::len, 0))?;
-        class.define_method(id!($ruby, "is_empty"), method!(<$type>::is_empty, 0))?;
-        class.define_method(id!($ruby, "get"), method!(<$type>::get, 1))?;
-        class.define_method(id!($ruby, "peek_front"), method!(<$type>::peek_front, 0))?;
-        class.define_method(id!($ruby, "peek_back"), method!(<$type>::peek_back, 0))?;
-        class.define_method(id!($ruby, "push_back"), method!(<$type>::push_back, 1))?;
-        class.define_method(id!($ruby, "push_front"), method!(<$type>::push_front, 1))?;
-        class.define_method(id!($ruby, "pop_front"), method!(<$type>::pop_front, 0))?;
-        class.define_method(id!($ruby, "pop_back"), method!(<$type>::pop_back, 0))?;
-        class.define_method(id!($ruby, "clear"), method!(<$type>::clear, 0))?;
-        class.define_method(id!($ruby, "scan"), method!(<$type>::scan, 1))?;
-        class.define_method(id!($ruby, "commit"), method!(<$type>::commit, 0))?;
-        class.define_method(id!($ruby, "rollback"), method!(<$type>::rollback, 0))?;
-    }};
-}
-
-macro_rules! register_scan {
-    ($ruby:expr, $module:expr, $name:literal, $type:ty) => {{
-        let class = $module.define_class(id!($ruby, $name), $ruby.class_object())?;
-        class.define_method(id!($ruby, "next"), method!(<$type>::next, 0))?;
-        class.define_method(id!($ruby, "close"), method!(<$type>::close, 0))?;
-    }};
-}
+use crate::ROOT_MOD;
+use magnus::{Error, Ruby};
 
 /// Registers the concrete native state classes.
 ///
@@ -73,32 +16,18 @@ macro_rules! register_scan {
 pub(crate) fn register(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.get_inner(&ROOT_MOD);
 
-    register_value!(ruby, module, "NativeJsonValueState", NativeJsonValueState);
-    register_value!(
-        ruby,
-        module,
-        "NativeMessageValueState",
-        NativeMessageValueState
-    );
-    register_map!(ruby, module, "NativeJsonMapState", NativeJsonMapState);
-    register_map!(ruby, module, "NativeMessageMapState", NativeMessageMapState);
-    register_deque!(ruby, module, "NativeJsonDequeState", NativeJsonDequeState);
-    register_deque!(
-        ruby,
-        module,
-        "NativeMessageDequeState",
-        NativeMessageDequeState
-    );
-    register_scan!(ruby, module, "NativeJsonDequeScan", NativeJsonDequeScan);
-    register_scan!(ruby, module, "NativeJsonMapScan", NativeJsonMapScan);
-    register_scan!(
-        ruby,
-        module,
-        "NativeMessageDequeScan",
-        NativeMessageDequeScan
-    );
-    register_scan!(ruby, module, "NativeMessageMapScan", NativeMessageMapScan);
-    register_scan!(ruby, module, "NativeMapKeyScan", NativeMapKeyScan);
+    NativeJsonValueState::register(ruby, module)?;
+    NativeMessageValueState::register(ruby, module)?;
+    NativeJsonMapState::register(ruby, module)?;
+    NativeMessageMapState::register(ruby, module)?;
+    NativeSetState::register(ruby, module)?;
+    NativeJsonDequeState::register(ruby, module)?;
+    NativeMessageDequeState::register(ruby, module)?;
+    NativeJsonDequeScan::register(ruby, module)?;
+    NativeJsonMapScan::register(ruby, module)?;
+    NativeMessageDequeScan::register(ruby, module)?;
+    NativeMessageMapScan::register(ruby, module)?;
+    NativeMapKeyScan::register(ruby, module)?;
 
     Ok(())
 }

data/ext/prosody/src/handler/state/scan.rs

@@ -3,150 +3,69 @@
 //! Cancellation can discard an orphaned chunk. The attempt then closes the
 //! cursor through the Ruby `ensure`, so no later operation observes that chunk.
 
-use super::state_error;
-use crate::bridge::{Bridge, QUEUE_CLASS};
+use super::{run_state, wrapped_class};
+use crate::bridge::Bridge;
 use crate::handler::message::Message;
-use crate::id;
-use crate::tracing_util::extract_opentelemetry_context;
-use crate::util::ThreadSafeValue;
-use magnus::value::ReprValue;
-use magnus::{Error, IntoValue, Ruby, Value};
+use magnus::{Error, IntoValue, Module, RArray, RModule, Ruby, Value, method};
 use opentelemetry::propagation::TextMapCompositePropagator;
-use opentelemetry::trace::FutureExt;
 use prosody::consumer::event_context::StateCursor;
 use prosody::consumer::message::ConsumerMessage;
 use serde_json::Value as JsonValue;
 use serde_magnus::serialize;
-use std::cell::RefCell;
-use std::collections::VecDeque;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
 use tracing::Span;
 
-#[allow(clippy::unwrap_used, reason = "256 is a nonzero literal")]
-const SCAN_READY_CHUNK_SIZE: NonZeroUsize = NonZeroUsize::new(256).unwrap();
-
-struct ScanInner<T> {
-    cursor: Arc<StateCursor<T>>,
-    buffer: VecDeque<T>,
-    done: bool,
-}
-
-macro_rules! drive_scan {
-    ($ruby:expr, $this:expr, $inner:expr, |$item:ident| $convert:block) => {{
-        loop {
-            if let Some($item) = $inner.buffer.pop_front() {
-                return $convert;
-            }
-            if $inner.done {
-                return Ok($ruby.qnil().as_value());
-            }
-            let cursor = Arc::clone(&$inner.cursor);
-            let context = extract_opentelemetry_context($ruby, &$this.propagator)?;
-            let chunk = $this
-                .bridge
-                .wait_for(
-                    $ruby,
-                    async move {
-                        cursor
-                            .next_ready_chunk(SCAN_READY_CHUNK_SIZE)
-                            .with_context(context)
-                            .await
-                    },
-                    Span::current(),
-                )?
-                .map_err(|error| state_error($ruby, &error))?;
-            match chunk {
-                Some(items) => $inner.buffer.extend(items),
-                None => {
-                    $inner.done = true;
-                    let cursor = Arc::clone(&$inner.cursor);
-                    $this.bridge.wait_for(
-                        $ruby,
-                        async move { cursor.close().await },
-                        Span::current(),
-                    )?;
-                    return Ok($ruby.qnil().as_value());
-                }
-            }
-        }
-    }};
-}
+const SCAN_READY_CHUNK_SIZE: NonZeroUsize = match NonZeroUsize::new(256) {
+    Some(size) => size,
+    None => NonZeroUsize::MIN,
+};
 
 macro_rules! native_scan {
     ($name:ident, $class:literal, $item:ty, |$ruby:ident, $item_name:ident| $convert:block) => {
         /// Native cursor with one item type.
         #[magnus::wrap(class = $class)]
         pub struct $name {
-            inner: RefCell<ScanInner<$item>>,
-            lock: ThreadSafeValue,
+            cursor: Arc<StateCursor<$item>>,
             bridge: Bridge,
             propagator: Arc<TextMapCompositePropagator>,
         }
 
         impl $name {
-            pub(super) fn new(
-                ruby: &Ruby,
-                cursor: Box<StateCursor<$item>>,
+            pub(crate) fn new(
+                cursor: StateCursor<$item>,
                 bridge: Bridge,
                 propagator: Arc<TextMapCompositePropagator>,
-            ) -> Result<Self, Error> {
-                let queue: Value = ruby.get_inner(&QUEUE_CLASS).funcall(id!(ruby, "new"), ())?;
-                let _: Value = queue.funcall(id!(ruby, "push"), (ruby.qnil(),))?;
-                Ok(Self {
-                    inner: RefCell::new(ScanInner {
-                        cursor: Arc::from(cursor),
-                        buffer: VecDeque::new(),
-                        done: false,
-                    }),
-                    lock: ThreadSafeValue::new(queue, bridge.clone()),
+            ) -> Self {
+                Self {
+                    cursor: Arc::new(cursor),
                     bridge,
                     propagator,
-                })
-            }
-
-            fn acquire(&self, ruby: &Ruby) -> Result<(), Error> {
-                let _: Value = self.lock.get(ruby).funcall(id!(ruby, "pop"), ())?;
-                Ok(())
-            }
-
-            fn release(&self, ruby: &Ruby) {
-                let _: Result<Value, Error> = self
-                    .lock
-                    .get(ruby)
-                    .funcall(id!(ruby, "push"), (ruby.qnil(),));
-            }
-
-            pub(super) fn next(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-                this.acquire(ruby)?;
-                let out = Self::next_locked(ruby, this);
-                this.release(ruby);
-                out
+                }
             }
 
-            fn next_locked(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-                let inner = &mut *this.inner.borrow_mut();
-                drive_scan!(ruby, this, inner, |$item_name| {
-                    let $ruby = ruby;
-                    $convert
-                })
+            /// Returns the next ready chunk as an Array, or `nil` after the
+            /// end. Read failures raise the typed state errors.
+            fn next_chunk($ruby: &Ruby, this: &Self) -> Result<Option<RArray>, Error> {
+                let cursor = Arc::clone(&this.cursor);
+                run_state($ruby, &this.bridge, &this.propagator, async move {
+                    cursor.next_ready_chunk(SCAN_READY_CHUNK_SIZE).await
+                })?
+                .map(|items| $ruby.ary_try_from_iter(items.into_iter().map(|$item_name| $convert)))
+                .transpose()
             }
 
-            pub(super) fn close(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-                this.acquire(ruby)?;
-                let out = Self::close_locked(ruby, this);
-                this.release(ruby);
-                out
+            fn close(ruby: &Ruby, this: &Self) -> Result<(), Error> {
+                let cursor = Arc::clone(&this.cursor);
+                this.bridge
+                    .wait_for(ruby, async move { cursor.close().await }, Span::current())
             }
 
-            fn close_locked(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
-                let inner = &mut *this.inner.borrow_mut();
-                inner.done = true;
-                inner.buffer.clear();
-                let cursor = Arc::clone(&inner.cursor);
-                this.bridge
-                    .wait_for(ruby, async move { cursor.close().await }, Span::current())?;
-                Ok(ruby.qnil().as_value())
+            pub(super) fn register(ruby: &Ruby, module: RModule) -> Result<(), Error> {
+                let class = wrapped_class(ruby, module, $class)?;
+                class.define_method("next_chunk", method!($name::next_chunk, 0))?;
+                class.define_method("close", method!($name::close, 0))?;
+                Ok(())
             }
         }
     };
@@ -156,7 +75,7 @@ native_scan!(
     NativeJsonDequeScan,
     "Prosody::NativeJsonDequeScan",
     JsonValue,
-    |ruby, item| { serialize(ruby, &item) }
+    |ruby, item| { serialize::<_, Value>(ruby, &item) }
 );
 native_scan!(
     NativeJsonMapScan,
@@ -189,30 +108,3 @@ native_scan!(
     String,
     |ruby, item| { Ok(item.into_value_with(ruby)) }
 );
-
-pub(crate) fn published_map_scan(
-    ruby: &Ruby,
-    cursor: Box<StateCursor<(String, JsonValue)>>,
-    bridge: Bridge,
-    propagator: Arc<TextMapCompositePropagator>,
-) -> Result<NativeJsonMapScan, Error> {
-    NativeJsonMapScan::new(ruby, cursor, bridge, propagator)
-}
-
-pub(crate) fn published_map_key_scan(
-    ruby: &Ruby,
-    cursor: Box<StateCursor<String>>,
-    bridge: Bridge,
-    propagator: Arc<TextMapCompositePropagator>,
-) -> Result<NativeMapKeyScan, Error> {
-    NativeMapKeyScan::new(ruby, cursor, bridge, propagator)
-}
-
-pub(crate) fn published_deque_scan(
-    ruby: &Ruby,
-    cursor: Box<StateCursor<JsonValue>>,
-    bridge: Bridge,
-    propagator: Arc<TextMapCompositePropagator>,
-) -> Result<NativeJsonDequeScan, Error> {
-    NativeJsonDequeScan::new(ruby, cursor, bridge, propagator)
-}