mini_racer_rs 1.0.0

data/ext/mini_racer_rs/src/host.rs

@@ -0,0 +1,339 @@
+use std::cell::Cell;
+use std::os::fd::{AsRawFd, IntoRawFd};
+use std::sync::OnceLock;
+use std::time::Duration;
+
+use magnus::error::ErrorType;
+use magnus::gc::Marker;
+use magnus::value::ReprValue;
+use magnus::{Class, Error, Exception, Integer, RArray, RString, Ruby, Value, kwargs};
+use mini_racer_engine::process::fork;
+use mini_racer_engine::{
+    CallbackReply, EngineError, Host, JsError, JsErrorKind, JsText, WaitHandle, WaitOutcome,
+};
+
+use crate::encode;
+use crate::gc_root::OwnedRoot;
+use crate::{context, decode, errors, rb_raw};
+
+struct SpinBudget {
+    gvl: Duration,
+    nogvl: Duration,
+}
+
+// Unstable tuning knob: MINI_RACER_RS_SPIN_US=<with GVL>,<without GVL>.
+fn budget() -> &'static SpinBudget {
+    static BUDGET: OnceLock<SpinBudget> = OnceLock::new();
+    BUDGET.get_or_init(|| {
+        let setting = std::env::var("MINI_RACER_RS_SPIN_US").unwrap_or_default();
+        let parts: Vec<Option<u64>> = setting
+            .split(',')
+            .map(|part| part.trim().parse().ok())
+            .collect();
+        let at = |i: usize, default: u64| {
+            Duration::from_micros(parts.get(i).copied().flatten().unwrap_or(default))
+        };
+        SpinBudget {
+            gvl: at(0, 20),
+            nogvl: at(1, 50),
+        }
+    })
+}
+
+/// What a context's callbacks run: its attached callables by id, and where
+/// the exception the latest callback raised is kept, as `mini_racer` keeps one
+/// per context and clears it after every dispatch, nested ones included.
+pub struct Callbacks<'r> {
+    pub callables: RArray,
+    pub raised: &'r OwnedRoot<Value>,
+}
+
+/// Waits for a runner from a Ruby thread: spins holding the GVL, then parks
+/// the fiber under a fiber scheduler, or else releases the GVL, spins and
+/// parks the thread. A Ruby interrupt wakes the park; traps run and the wait
+/// goes on, while an exception (Timeout, Thread#raise, #kill) cancels the
+/// dispatch and is raised once the engine has its response.
+pub struct RubyHost<'r> {
+    ruby: &'r Ruby,
+    pending: Option<Error>,
+    callbacks: Option<Callbacks<'r>>,
+    // The context's IO on a notifier descriptor of its own, which waits under
+    // a fiber scheduler need; a host without one blocks the thread.
+    waiter: Option<&'r Waiter>,
+}
+
+/// The IO a fiber scheduler waits on for one context's runner, and the fork
+/// epoch it was made in: a forked child that takes the context over gives it
+/// a runner of its own, whose descriptor that IO does not read.
+#[derive(Default)]
+pub struct Waiter {
+    io: OwnedRoot<Value>,
+    epoch: Cell<u64>,
+}
+
+impl Waiter {
+    pub fn mark(&self, marker: &Marker) {
+        self.io.mark(marker);
+    }
+
+    pub fn take(&self, ruby: &Ruby) -> Option<Value> {
+        self.io.take(ruby)
+    }
+}
+
+impl<'r> RubyHost<'r> {
+    pub const fn new(ruby: &'r Ruby) -> Self {
+        Self {
+            ruby,
+            pending: None,
+            callbacks: None,
+            waiter: None,
+        }
+    }
+
+    pub const fn with_callbacks(ruby: &'r Ruby, callbacks: Callbacks<'r>) -> Self {
+        Self {
+            ruby,
+            pending: None,
+            callbacks: Some(callbacks),
+            waiter: None,
+        }
+    }
+
+    #[must_use]
+    pub const fn waiting_on(mut self, waiter: &'r Waiter) -> Self {
+        self.waiter = Some(waiter);
+        self
+    }
+
+    /// The Ruby exception that cancelled the dispatch outranks whatever the
+    /// engine returned.
+    pub fn finish<T>(self, result: Result<T, EngineError>) -> Result<T, Error> {
+        // mini_racer raises an interrupt before it clears the kept exception,
+        // so a later rethrow of that error still raises it.
+        if let Some(pending) = self.pending {
+            return Err(pending);
+        }
+        let raised = self
+            .callbacks
+            .and_then(|callbacks| callbacks.raised.take(self.ruby))
+            .and_then(Exception::from_value);
+        match (result, raised) {
+            (
+                Err(EngineError::Js(JsError {
+                    kind: JsErrorKind::HostException,
+                    ..
+                })),
+                Some(raised),
+            ) => Err(Error::from(raised)),
+            (result, _) => result.map_err(|error| errors::engine(self.ruby, error)),
+        }
+    }
+
+    // Under a fiber scheduler only this fiber waits: the runner's answer makes
+    // the context's notifier readable and the scheduler resumes the fiber,
+    // while whatever the scheduler raises into it (a timeout, a stop) cancels
+    // the dispatch, even when the answer came in meanwhile. None means no
+    // notifier is to be had, so the thread waits instead.
+    fn wait_in_fiber(&mut self, wait: &WaitHandle<'_>) -> Option<WaitOutcome> {
+        let io = self.waiter_io(wait)?;
+        loop {
+            let mut raised = None;
+            wait.park_notified(|| raised = wait_readable(io).err())
+                .ok()?;
+            if let Some(error) = raised {
+                self.pending = Some(error);
+                return Some(WaitOutcome::Cancel);
+            }
+            if wait.ready() {
+                return Some(WaitOutcome::Ready);
+            }
+        }
+    }
+
+    // Made once per context and fork epoch, and again if Ruby code closed it;
+    // the descriptor is Ruby's own copy, so closing it never touches the
+    // engine's.
+    fn waiter_io(&self, wait: &WaitHandle<'_>) -> Option<Value> {
+        let ruby = self.ruby;
+        let waiter = self.waiter?;
+        let epoch = fork::epoch();
+        if let Some(io) = waiter.io.get(ruby)
+            && waiter.epoch.get() == epoch
+            && !io.funcall::<_, _, bool>("closed?", ()).unwrap_or(true)
+        {
+            return Some(io);
+        }
+        let fd = wait.notifier().ok()?;
+        let io: Value = ruby
+            .class_io()
+            .funcall("for_fd", (fd.as_raw_fd(), kwargs!("autoclose" => true)))
+            .ok()?;
+        let _owned_by_io = fd.into_raw_fd();
+        waiter.io.set(ruby, io);
+        waiter.epoch.set(epoch);
+        Some(io)
+    }
+
+    // Keeps the first exception the scheduler raises for after the dispatch,
+    // then leaves the rest of the wait to the thread, so a scheduler that
+    // keeps raising cannot spin here.
+    fn wait_blocking_in_fiber(&mut self, wait: &WaitHandle<'_>) {
+        let Some(io) = self.waiter_io(wait) else {
+            return;
+        };
+        while !wait.ready() {
+            let mut raised = None;
+            if wait
+                .park_notified(|| raised = wait_readable(io).err())
+                .is_err()
+            {
+                return;
+            }
+            if let Some(error) = raised {
+                self.pending.get_or_insert(error);
+                return;
+            }
+        }
+    }
+
+    // A captured throw resumes through Ruby's error info, which any protected
+    // call in between would clear, so nothing runs Ruby code until it does.
+    fn jumping(&self) -> bool {
+        self.pending
+            .as_ref()
+            .is_some_and(|pending| matches!(pending.error_type(), ErrorType::Jump(_)))
+    }
+
+    // mini_racer's order: the id comes off the end of the arguments, and a
+    // reply it cannot send raises its internal error with the encoder's text.
+    fn run(&self, request: &[u8]) -> Result<Vec<u8>, Error> {
+        let ruby = self.ruby;
+        let bad = || errors::runtime(ruby, "bad callback id");
+        let args = RArray::from_value(decode::value(ruby, request)?).ok_or_else(bad)?;
+        let id = Integer::from_value(args.pop::<Value>()?).ok_or_else(bad)?;
+        let id = isize::try_from(id.to_i64()?).map_err(|_| bad())?;
+        let callables = self
+            .callbacks
+            .as_ref()
+            .map(|callbacks| callbacks.callables)
+            .ok_or_else(bad)?;
+        if id < 0 || id.cast_unsigned() >= callables.len() {
+            return Err(bad());
+        }
+        let callable = callables.entry::<Value>(id)?;
+        let result = rb_raw::call_with_array(ruby, callable, args)?;
+        encode::encode(ruby, result, |message| errors::internal(ruby, message))
+    }
+}
+
+fn wait_readable(io: Value) -> Result<(), Error> {
+    let _: Value = io.funcall("wait_readable", ())?;
+    Ok(())
+}
+
+fn exception(ruby: &Ruby, error: &Error) -> Option<Exception> {
+    match error.error_type() {
+        ErrorType::Jump(_) => None,
+        ErrorType::Exception(exception) => Some(*exception),
+        ErrorType::Error(class, message) => class
+            .new_instance((ruby.str_new(message),))
+            .map_or_else(|error| exception(ruby, &error), Some),
+    }
+}
+
+// What V8 throws for a raising callback: the exception's to_s, in its own
+// encoding, or mini_racer's fallback text.
+fn message(ruby: &Ruby, exception: Exception) -> JsText {
+    exception
+        .funcall::<_, _, RString>("to_s", ())
+        .ok()
+        .and_then(|text| context::js_text(ruby, text).ok())
+        .unwrap_or_else(|| JsText::from("Ruby exception"))
+}
+
+impl Host for RubyHost<'_> {
+    fn wait(&mut self, wait: &WaitHandle<'_>) -> WaitOutcome {
+        let budget = budget();
+        if wait.spin(budget.gvl) {
+            return WaitOutcome::Ready;
+        }
+        if rb_raw::fiber_scheduler(self.ruby)
+            && let Some(outcome) = self.wait_in_fiber(wait)
+        {
+            return outcome;
+        }
+        let unparker = wait.unparker();
+        loop {
+            let parked = rb_raw::nogvl(
+                self.ruby,
+                || {
+                    if !wait.spin(budget.nogvl) {
+                        wait.park();
+                    }
+                },
+                &move || unparker.unpark(),
+            );
+            if wait.ready() {
+                return WaitOutcome::Ready;
+            }
+            if parked.as_ref().is_some_and(Result::is_err) {
+                self.pending = Some(errors::internal(self.ruby, "panic while waiting"));
+                return WaitOutcome::Cancel;
+            }
+            if let Err(error) = rb_raw::check_ints(self.ruby) {
+                self.pending = Some(error);
+                return WaitOutcome::Cancel;
+            }
+        }
+    }
+
+    // Interrupts cannot end this wait, but they still run: a pending one would
+    // otherwise make every rb_nogvl return at once and keep the GVL held. An
+    // exception they raise is kept and raised once the dispatch is over.
+    fn wait_blocking(&mut self, wait: &WaitHandle<'_>) {
+        if !self.jumping() && rb_raw::fiber_scheduler(self.ruby) {
+            self.wait_blocking_in_fiber(wait);
+        }
+        if self.jumping() {
+            while !wait.ready() {
+                wait.park();
+            }
+            return;
+        }
+        while !wait.ready() {
+            let parked = rb_raw::nogvl(
+                self.ruby,
+                || {
+                    while !wait.ready() {
+                        wait.park();
+                    }
+                },
+                &|| {},
+            );
+            if parked.is_none()
+                && let Err(error) = rb_raw::check_ints(self.ruby)
+            {
+                self.pending.get_or_insert(error);
+            }
+        }
+    }
+
+    // A throw or Thread#kill out of the callable aborts the dispatch and
+    // resumes once it is over.
+    fn callback(&mut self, request: &[u8]) -> CallbackReply {
+        let error = match self.run(request) {
+            Ok(reply) => return CallbackReply::Value(reply),
+            Err(error) => error,
+        };
+        let Some(exception) = exception(self.ruby, &error) else {
+            self.pending.get_or_insert(error);
+            return CallbackReply::Abort;
+        };
+        let message = message(self.ruby, exception);
+        if let Some(callbacks) = &self.callbacks {
+            callbacks.raised.set(self.ruby, exception.as_value());
+        }
+        CallbackReply::Raised(message)
+    }
+}

data/ext/mini_racer_rs/src/lib.rs

@@ -0,0 +1,44 @@
+mod context;
+mod decode;
+mod encode;
+mod errors;
+mod fork;
+mod gc_root;
+mod guard;
+mod host;
+mod options;
+mod platform;
+#[allow(
+    unsafe_code,
+    reason = "the only module that calls rb-sys directly (invariant I6)"
+)]
+mod rb_raw;
+mod snapshot;
+
+use magnus::{Error, Module, Ruby};
+
+macro_rules! export {
+    (method $f:path, $($arity:tt)+) => {
+        magnus::method!($f, $($arity)+)
+    };
+    (function $f:path, $($arity:tt)+) => {
+        magnus::function!($f, $($arity)+)
+    };
+}
+pub(crate) use export;
+
+#[magnus::init(name = "mini_racer_rs")]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let racer = ruby.define_module("MiniRacer")?;
+    let rs = ruby.define_module("MiniRacerRs")?;
+    rs.const_set("NATIVE_VERSION", env!("CARGO_PKG_VERSION"))?;
+    rs.const_set("V8_VERSION", mini_racer_engine::process::v8_version())?;
+    racer.define_class("JavaScriptFunction", ruby.class_object())?;
+    gc_root::init(ruby, rs)?;
+    errors::init(ruby)?;
+    platform::init(ruby, racer)?;
+    context::init(ruby, racer)?;
+    snapshot::init(ruby, racer)?;
+    fork::init(ruby, rs)?;
+    Ok(())
+}

data/ext/mini_racer_rs/src/options.rs

@@ -0,0 +1,269 @@
+use std::time::Duration;
+
+use mini_racer_engine::{ContextConfig, InvalidSnapshot, SnapshotBlob};
+
+/// An option value, as far as the rules below need to see it.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum OptionValue {
+    Fixnum(i64),
+    Nil,
+    False,
+    /// A `MiniRacer::Snapshot`, by the blob it shares or why that blob is
+    /// refused; given only for `snapshot:`.
+    Snapshot(Result<SnapshotBlob, InvalidSnapshot>),
+    /// Anything else, by the name Ruby's type errors give it.
+    Other(String),
+}
+
+impl OptionValue {
+    // Ruby's type errors name nil and false by value.
+    fn type_name(&self) -> String {
+        match self {
+            Self::Fixnum(_) => "Integer".to_owned(),
+            Self::Nil => "nil".to_owned(),
+            Self::False => "false".to_owned(),
+            Self::Snapshot(_) => "MiniRacer::Snapshot".to_owned(),
+            Self::Other(name) => name.clone(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum OptionError {
+    #[error("wrong argument type {0} (expected Integer)")]
+    Type(String),
+    #[error("wrong argument type {0} (expected mini_racer/snapshot)")]
+    SnapshotType(String),
+    #[error("bad {0}")]
+    Range(&'static str),
+    #[error("bad keyword: {0}")]
+    Keyword(String),
+    #[error(transparent)]
+    InvalidSnapshot(InvalidSnapshot),
+}
+
+const INT32_MAX: i64 = i32::MAX as i64;
+const UINT32_MAX: i64 = u32::MAX as i64;
+
+fn fixnum(value: &OptionValue) -> Result<i64, OptionError> {
+    match value {
+        OptionValue::Fixnum(n) => Ok(*n),
+        other => Err(OptionError::Type(other.type_name())),
+    }
+}
+
+fn within(
+    value: &OptionValue,
+    name: &'static str,
+    range: impl std::ops::RangeBounds<i64>,
+) -> Result<i64, OptionError> {
+    let n = fixnum(value)?;
+    if range.contains(&n) {
+        Ok(n)
+    } else {
+        Err(OptionError::Range(name))
+    }
+}
+
+/// `Context.new` keywords in the order given; `mini_racer` 0.22.1 checks them
+/// last to first and raises on the first bad one.
+pub fn configure(
+    options: impl DoubleEndedIterator<Item = (String, OptionValue)>,
+) -> Result<ContextConfig, OptionError> {
+    let mut config = ContextConfig::default();
+    let mut refused = None;
+    for (key, value) in options.rev() {
+        match key.as_str() {
+            "timeout" => {
+                let ms = within(&value, "timeout", 0..=INT32_MAX)?;
+                config.timeout = u64::try_from(ms)
+                    .ok()
+                    .filter(|ms| *ms > 0)
+                    .map(Duration::from_millis);
+            }
+            "marshal_stack_depth" => {
+                fixnum(&value)?;
+            }
+            "ensure_gc_after_idle" => {
+                let ms = within(&value, "ensure_gc_after_idle", 0..=INT32_MAX)?;
+                config.gc_after_idle = u64::try_from(ms)
+                    .ok()
+                    .filter(|ms| *ms > 0)
+                    .map(Duration::from_millis);
+            }
+            "max_memory" => {
+                let bytes = within(&value, "max_memory", 0..UINT32_MAX)?;
+                config.max_memory = u64::try_from(bytes).ok().filter(|bytes| *bytes > 0);
+            }
+            "snapshot" => match value {
+                OptionValue::Nil => {}
+                // mini_racer treats an empty blob as no snapshot.
+                OptionValue::Snapshot(Ok(blob)) => {
+                    config.snapshot = (!blob.is_empty()).then_some(blob);
+                }
+                // mini_racer's V8 reads the blob only once every option passes.
+                OptionValue::Snapshot(Err(invalid)) => refused = Some(invalid),
+                other => return Err(OptionError::SnapshotType(other.type_name())),
+            },
+            // mini_racer turns it on for any value but nil and false.
+            "verbose_exceptions" => {
+                config.verbose_exceptions = !matches!(value, OptionValue::Nil | OptionValue::False);
+            }
+            _ => return Err(OptionError::Keyword(key)),
+        }
+    }
+    refused.map_or(Ok(config), |invalid| {
+        Err(OptionError::InvalidSnapshot(invalid))
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn configure_pairs(pairs: &[(&str, OptionValue)]) -> Result<ContextConfig, OptionError> {
+        configure(
+            pairs
+                .iter()
+                .map(|(key, value)| ((*key).to_owned(), value.clone())),
+        )
+    }
+
+    fn message(pairs: &[(&str, OptionValue)]) -> Option<String> {
+        configure_pairs(pairs).err().map(|e| e.to_string())
+    }
+
+    #[test]
+    fn timeout_is_milliseconds_and_zero_means_none() {
+        let config = configure_pairs(&[("timeout", OptionValue::Fixnum(250))]);
+        assert_eq!(
+            config.map(|c| c.timeout),
+            Ok(Some(Duration::from_millis(250)))
+        );
+        let config = configure_pairs(&[("timeout", OptionValue::Fixnum(0))]);
+        assert_eq!(config.map(|c| c.timeout), Ok(None));
+    }
+
+    #[test]
+    fn range_and_type_errors_match_mini_racer() {
+        assert_eq!(
+            message(&[("timeout", OptionValue::Fixnum(-1))]),
+            Some("bad timeout".to_owned())
+        );
+        assert_eq!(
+            configure_pairs(&[("timeout", OptionValue::Fixnum(INT32_MAX + 1))]).err(),
+            Some(OptionError::Range("timeout"))
+        );
+        assert_eq!(
+            message(&[("timeout", OptionValue::Nil)]),
+            Some("wrong argument type nil (expected Integer)".to_owned())
+        );
+        assert_eq!(
+            message(&[(
+                "marshal_stack_depth",
+                OptionValue::Other("String".to_owned())
+            )]),
+            Some("wrong argument type String (expected Integer)".to_owned())
+        );
+        assert!(configure_pairs(&[("marshal_stack_depth", OptionValue::Fixnum(-5))]).is_ok());
+        assert_eq!(
+            message(&[("max_memory", OptionValue::Fixnum(UINT32_MAX))]),
+            Some("bad max_memory".to_owned())
+        );
+        assert_eq!(
+            message(&[("ensure_gc_after_idle", OptionValue::False)]),
+            Some("wrong argument type false (expected Integer)".to_owned())
+        );
+    }
+
+    #[test]
+    fn max_memory_is_bytes_and_zero_means_none() {
+        let config = configure_pairs(&[("max_memory", OptionValue::Fixnum(200_000_000))]);
+        assert_eq!(config.map(|c| c.max_memory), Ok(Some(200_000_000)));
+        let config = configure_pairs(&[("max_memory", OptionValue::Fixnum(0))]);
+        assert_eq!(config.map(|c| c.max_memory), Ok(None));
+    }
+
+    #[test]
+    fn ensure_gc_after_idle_is_milliseconds_and_zero_means_none() {
+        let config = configure_pairs(&[("ensure_gc_after_idle", OptionValue::Fixnum(25))]);
+        assert_eq!(
+            config.map(|c| c.gc_after_idle),
+            Ok(Some(Duration::from_millis(25)))
+        );
+        let config = configure_pairs(&[("ensure_gc_after_idle", OptionValue::Fixnum(0))]);
+        assert_eq!(config.map(|c| c.gc_after_idle), Ok(None));
+    }
+
+    #[test]
+    fn keys_are_checked_last_to_first() {
+        let pairs = [
+            ("timeout", OptionValue::Other("String".to_owned())),
+            ("bogus", OptionValue::Fixnum(1)),
+        ];
+        assert_eq!(message(&pairs), Some("bad keyword: bogus".to_owned()));
+        let pairs = [
+            ("bogus", OptionValue::Fixnum(1)),
+            ("timeout", OptionValue::Other("String".to_owned())),
+        ];
+        assert_eq!(
+            configure_pairs(&pairs).err(),
+            Some(OptionError::Type("String".to_owned()))
+        );
+    }
+
+    #[test]
+    fn verbose_exceptions_is_any_value_but_nil_and_false() {
+        for (value, verbose) in [
+            (OptionValue::Nil, false),
+            (OptionValue::False, false),
+            (OptionValue::Other("TrueClass".to_owned()), true),
+            (OptionValue::Other("String".to_owned()), true),
+            (OptionValue::Fixnum(0), true),
+        ] {
+            let config = configure_pairs(&[("verbose_exceptions", value)]);
+            assert_eq!(config.map(|c| c.verbose_exceptions), Ok(verbose));
+        }
+    }
+
+    #[test]
+    fn a_snapshot_must_be_one_and_nil_or_an_empty_one_is_none() {
+        let empty = configure_pairs(&[(
+            "snapshot",
+            OptionValue::Snapshot(Ok(SnapshotBlob::default())),
+        )]);
+        assert_eq!(empty.map(|config| config.snapshot), Ok(None));
+        let nil = configure_pairs(&[("snapshot", OptionValue::Nil)]);
+        assert_eq!(nil.map(|config| config.snapshot), Ok(None));
+        assert_eq!(
+            configure_pairs(&[("snapshot", OptionValue::False)]).map(drop),
+            Err(OptionError::SnapshotType("false".to_owned()))
+        );
+        assert_eq!(
+            configure_pairs(&[(
+                "snapshot",
+                OptionValue::Other("mini_racer/context".to_owned())
+            )])
+            .map(drop),
+            Err(OptionError::SnapshotType("mini_racer/context".to_owned()))
+        );
+    }
+
+    #[test]
+    fn a_refused_blob_raises_only_once_every_option_passes() {
+        let refused = OptionValue::Snapshot(Err(InvalidSnapshot::Version));
+        assert_eq!(
+            configure_pairs(&[("snapshot", refused.clone())]).err(),
+            Some(OptionError::InvalidSnapshot(InvalidSnapshot::Version))
+        );
+        for pairs in [
+            [("timeout", OptionValue::Nil), ("snapshot", refused.clone())],
+            [("snapshot", refused), ("timeout", OptionValue::Nil)],
+        ] {
+            assert_eq!(
+                message(&pairs),
+                Some("wrong argument type nil (expected Integer)".to_owned())
+            );
+        }
+    }
+}

data/ext/mini_racer_rs/src/platform.rs

@@ -0,0 +1,42 @@
+use magnus::scan_args::scan_args;
+use magnus::value::ReprValue;
+use magnus::{Error, Module, Object, RArray, RHash, RModule, RString, Ruby, TryConvert, Value};
+use mini_racer_engine::process::platform;
+
+use crate::{errors, export, rb_raw};
+
+pub fn init(ruby: &Ruby, racer: RModule) -> Result<(), Error> {
+    let class = racer.define_class("Platform", ruby.class_object())?;
+    class.define_singleton_method("set_flags!", export!(function set_flags, -1))?;
+    Ok(())
+}
+
+fn set_flags(ruby: &Ruby, args: &[Value]) -> Result<(), Error> {
+    let args = scan_args::<(), (), RArray, (), RHash, ()>(args)?;
+    for name in args.splat {
+        push(ruby, name, None)?;
+    }
+    let mut pairs = Vec::new();
+    args.keywords.foreach(|name: Value, value: Value| {
+        pairs.push((name, value));
+        Ok(magnus::r_hash::ForEach::Continue)
+    })?;
+    for (name, value) in pairs {
+        push(ruby, name, Some(value))?;
+    }
+    Ok(())
+}
+
+fn to_s(ruby: &Ruby, value: Value) -> Result<Vec<u8>, Error> {
+    let string = RString::try_convert(value.funcall::<_, _, Value>("to_s", ())?)?;
+    Ok(rb_raw::string_bytes(ruby, string))
+}
+
+fn push(ruby: &Ruby, name: Value, value: Option<Value>) -> Result<(), Error> {
+    let name = to_s(ruby, name)?;
+    let value = match value {
+        Some(value) if !value.is_nil() => Some(to_s(ruby, value)?),
+        _ => None,
+    };
+    platform::push_flag(&name, value.as_deref()).map_err(|e| errors::flag(ruby, e))
+}