nosj 0.1.0

data/ext/nosj/src/sink.rs

@@ -0,0 +1,370 @@
+//! The nosj sinks: `RubyValueSink` builds Ruby VALUEs directly during
+//! the parse (with interned-key caches and gem-compatible option
+//! handling); `NullSink` powers `NOSJ.valid?` by discarding every
+//! event. Raw VALUE construction helpers live here too.
+
+use ahash::AHashMap;
+
+use crate::state::VStackShadow;
+
+/// Sanity ceiling for pending values (memory bomb guard), not a design limit.
+const SINK_STACK_MAX: usize = 1 << 26;
+
+/// The JSON gem's default nesting limit; matching it is part of drop-in
+/// compatibility (gem raises NestingError past 100 levels).
+pub(crate) const MAX_NESTING: usize = 100;
+
+const KEY_CACHE_CAP: usize = 2048;
+
+/// Why a sink stopped the drive; mapped onto the gem's exceptions in
+/// [`crate::parse::finish_drive`].
+pub(crate) enum SinkAbort {
+    Overflow,
+    BadBigint,
+    TooDeep,
+}
+
+/// `RB_INT2FIX` ported from Ruby's public inline headers: fixnums are
+/// `(i << 1) + 1` for `|i| <= LONG_MAX / 2`, and the range is defined by
+/// the C `long`, which is 32-bit on Windows (LLP64): fixnums there hold
+/// only 31 bits, and tagging anything wider crashes Ruby with
+/// "Unnormalized Fixnum value". C extensions get the check inlined by the
+/// header; going through the extern `rb_ll2inum` costs an FFI call per
+/// integer. Non-fixable values still take the call.
+// The widening is an identity on LP64 hosts (clippy flags it there) but
+// required on Windows, where c_long is 32-bit.
+#[allow(clippy::unnecessary_cast)]
+#[inline(always)]
+fn int_to_raw(i: i64) -> rb_sys::VALUE {
+    const FIXABLE_MIN: i64 = (std::os::raw::c_long::MIN / 2) as i64;
+    const FIXABLE_MAX: i64 = (std::os::raw::c_long::MAX / 2) as i64;
+    if (FIXABLE_MIN..=FIXABLE_MAX).contains(&i) {
+        ((i as u64) << 1).wrapping_add(1) as rb_sys::VALUE
+    } else {
+        unsafe { rb_sys::rb_ll2inum(i) }
+    }
+}
+
+#[inline(always)]
+fn str_to_raw(s: &str) -> rb_sys::VALUE {
+    unsafe {
+        rb_sys::rb_utf8_str_new(
+            s.as_ptr() as *const std::os::raw::c_char,
+            s.len() as std::os::raw::c_long,
+        )
+    }
+}
+
+#[inline(always)]
+fn interned_str_raw(s: &str) -> rb_sys::VALUE {
+    unsafe {
+        rb_sys::rb_enc_interned_str(
+            s.as_ptr() as *const std::os::raw::c_char,
+            s.len() as std::os::raw::c_long,
+            rb_sys::rb_utf8_encoding(),
+        )
+    }
+}
+
+/// Interned-key cache with epoch eviction: when the cap is reached the whole
+/// cache is cleared (hot keys repopulate immediately). Without this, one
+/// document with many unique keys (citm's numeric id maps) permanently fills
+/// the cache and every later document pays full interning per key, measured
+/// as a 1.37x regression on twitter parsed after citm in the same process.
+#[inline(always)]
+fn intern_key_cached(
+    key: &str,
+    map: &mut AHashMap<Box<str>, rb_sys::VALUE>,
+    shadow: &mut VStackShadow,
+) -> rb_sys::VALUE {
+    if key.is_empty() || key.len() > 64 {
+        return interned_str_raw(key);
+    }
+
+    if let Some(&v) = map.get(key) {
+        return v;
+    }
+
+    let raw = interned_str_raw(key);
+    if map.len() >= KEY_CACHE_CAP {
+        map.clear();
+        shadow.values.clear();
+    }
+    map.insert(Box::from(key), raw);
+    shadow.values.push(raw);
+    raw
+}
+
+/// Symbol-mode key cache. Static symbols from `rb_intern3` are permanent, so
+/// no GC shadow is needed; epoch-cleared at capacity like the string cache.
+#[inline(always)]
+fn intern_symbol_cached(key: &str, map: &mut AHashMap<Box<str>, rb_sys::VALUE>) -> rb_sys::VALUE {
+    #[inline(always)]
+    fn intern(key: &str) -> rb_sys::VALUE {
+        unsafe {
+            rb_sys::rb_id2sym(rb_sys::rb_intern3(
+                key.as_ptr() as *const std::os::raw::c_char,
+                key.len() as std::os::raw::c_long,
+                rb_sys::rb_utf8_encoding(),
+            ))
+        }
+    }
+
+    if key.is_empty() || key.len() > 64 {
+        return intern(key);
+    }
+    if let Some(&v) = map.get(key) {
+        return v;
+    }
+    let raw = intern(key);
+    if map.len() >= KEY_CACHE_CAP {
+        map.clear();
+    }
+    map.insert(Box::from(key), raw);
+    raw
+}
+
+/// nosj::Sink building Ruby VALUEs on the heap value stack. Pending
+/// VALUEs are kept alive by the pinned TypedData wrapper's precise dmark.
+pub(crate) struct RubyValueSink<'a> {
+    pub(crate) stack: &'a mut Vec<rb_sys::VALUE>,
+    pub(crate) keys: &'a mut AHashMap<Box<str>, rb_sys::VALUE>,
+    pub(crate) key_shadow: &'a mut VStackShadow,
+    pub(crate) depth: usize,
+    /// JSON.parse-compatible options; defaults keep the fast paths.
+    pub(crate) symbolize: bool,
+    pub(crate) freeze: bool,
+    pub(crate) max_nesting: usize,
+}
+
+// Tried and rejected (2026-07-10): a jiter-style cache of repeated VALUE
+// strings (rb_str_dup of a canonical copy, gated to heap lengths 40..=200
+// where the dup shares its buffer copy-on-write). Measured twitter parse
+// 0.95x vs 0.90x without: Ruby must dup for mutability where Python only
+// INCREFs, and the hash+insert overhead exceeds the CoW savings.
+
+impl RubyValueSink<'_> {
+    #[inline(always)]
+    fn push_raw(&mut self, raw: rb_sys::VALUE) -> Result<(), SinkAbort> {
+        if self.stack.len() >= SINK_STACK_MAX {
+            return Err(SinkAbort::Overflow);
+        }
+        self.stack.push(raw);
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn enter_container(&mut self) -> Result<(), SinkAbort> {
+        self.depth += 1;
+        if self.depth > self.max_nesting {
+            return Err(SinkAbort::TooDeep);
+        }
+        Ok(())
+    }
+}
+
+impl nosj::Sink for RubyValueSink<'_> {
+    type Error = SinkAbort;
+
+    #[inline(always)]
+    fn null(&mut self) -> Result<(), SinkAbort> {
+        self.push_raw(rb_sys::special_consts::Qnil as rb_sys::VALUE)
+    }
+
+    #[inline(always)]
+    fn boolean(&mut self, value: bool) -> Result<(), SinkAbort> {
+        self.push_raw(if value {
+            rb_sys::special_consts::Qtrue as rb_sys::VALUE
+        } else {
+            rb_sys::special_consts::Qfalse as rb_sys::VALUE
+        })
+    }
+
+    #[inline(always)]
+    fn int(&mut self, value: i64) -> Result<(), SinkAbort> {
+        self.push_raw(int_to_raw(value))
+    }
+
+    #[inline(always)]
+    fn float(&mut self, value: f64) -> Result<(), SinkAbort> {
+        self.push_raw(unsafe { rb_sys::rb_float_new(value) })
+    }
+
+    #[inline(always)]
+    fn big_int(&mut self, digits: &str) -> Result<(), SinkAbort> {
+        let c = std::ffi::CString::new(digits).map_err(|_| SinkAbort::BadBigint)?;
+        self.push_raw(unsafe { rb_sys::rb_cstr2inum(c.as_ptr(), 10) })
+    }
+
+    #[inline(always)]
+    fn str(&mut self, value: &str) -> Result<(), SinkAbort> {
+        let raw = if self.freeze {
+            // Gem parity: freeze mode dedupes strings via the fstring table.
+            interned_str_raw(value)
+        } else {
+            str_to_raw(value)
+        };
+        self.push_raw(raw)
+    }
+
+    #[inline(always)]
+    fn key(&mut self, key: &str) -> Result<(), SinkAbort> {
+        let raw = if self.symbolize {
+            intern_symbol_cached(key, self.keys)
+        } else {
+            intern_key_cached(key, self.keys, self.key_shadow)
+        };
+        self.push_raw(raw)
+    }
+
+    /// Lone-low-surrogate content: gem parity is a UTF-8-encoded Ruby string
+    /// carrying the raw WTF-8 bytes (broken coderange, like the gem's).
+    #[inline(always)]
+    fn str_bytes(&mut self, value: &[u8]) -> Result<(), SinkAbort> {
+        let raw = unsafe {
+            let s = rb_sys::rb_utf8_str_new(
+                value.as_ptr() as *const std::os::raw::c_char,
+                value.len() as std::os::raw::c_long,
+            );
+            if self.freeze {
+                rb_sys::rb_str_freeze(s)
+            } else {
+                s
+            }
+        };
+        self.push_raw(raw)
+    }
+
+    #[inline(always)]
+    fn key_bytes(&mut self, key: &[u8]) -> Result<(), SinkAbort> {
+        // Interning is skipped: these keys are pathological, not hot.
+        let raw = unsafe {
+            rb_sys::rb_utf8_str_new(
+                key.as_ptr() as *const std::os::raw::c_char,
+                key.len() as std::os::raw::c_long,
+            )
+        };
+        let frozen = unsafe { rb_sys::rb_str_freeze(raw) };
+        self.push_raw(frozen)
+    }
+
+    #[inline(always)]
+    fn begin_array(&mut self) -> Result<(), SinkAbort> {
+        self.enter_container()
+    }
+
+    #[inline(always)]
+    fn begin_object(&mut self) -> Result<(), SinkAbort> {
+        self.enter_container()
+    }
+
+    #[inline(always)]
+    fn mark(&self) -> usize {
+        self.stack.len()
+    }
+
+    // Note: eager arrays (begin_array allocating + array_checkpoint spilling)
+    // were measured SLOWER here; rb_ary_new + rb_ary_cat growth per small
+    // array loses to one exact-size rb_ary_new_from_values, and the hoped-for
+    // GC-marking savings didn't materialize (sweep/free dominates, not
+    // pending-stack marking). The default no-op hooks stay available for
+    // sinks where the trade differs.
+    #[inline(always)]
+    fn end_array(&mut self, mark: usize, _len: usize) -> Result<(), SinkAbort> {
+        self.depth -= 1;
+        let n = self.stack.len() - mark;
+        let raw = unsafe {
+            let a = rb_sys::rb_ary_new_from_values(
+                n as std::os::raw::c_long,
+                self.stack.as_ptr().add(mark),
+            );
+            if self.freeze {
+                rb_sys::rb_obj_freeze(a);
+            }
+            a
+        };
+        self.stack.truncate(mark);
+        self.push_raw(raw)
+    }
+
+    #[inline(always)]
+    fn end_object(&mut self, mark: usize, pairs: usize) -> Result<(), SinkAbort> {
+        self.depth -= 1;
+        let n = self.stack.len() - mark;
+        let hash_raw = unsafe { rb_sys::rb_hash_new_capa(pairs as std::os::raw::c_long) };
+        unsafe {
+            rb_sys::rb_hash_bulk_insert(
+                n as std::os::raw::c_long,
+                self.stack.as_ptr().add(mark),
+                hash_raw,
+            );
+            if self.freeze {
+                rb_sys::rb_obj_freeze(hash_raw);
+            }
+        }
+        self.stack.truncate(mark);
+        self.push_raw(hash_raw)
+    }
+}
+
+/// Validation-only sink: every event is a no-op except nesting-depth
+/// tracking, so `NOSJ.valid?` runs the full parser (tokenizers,
+/// string decode, number validation) without allocating a single VALUE.
+pub(crate) struct NullSink {
+    pub(crate) depth: usize,
+    pub(crate) max_nesting: usize,
+}
+
+impl nosj::Sink for NullSink {
+    type Error = SinkAbort;
+
+    fn null(&mut self) -> Result<(), SinkAbort> {
+        Ok(())
+    }
+    fn boolean(&mut self, _: bool) -> Result<(), SinkAbort> {
+        Ok(())
+    }
+    fn int(&mut self, _: i64) -> Result<(), SinkAbort> {
+        Ok(())
+    }
+    fn float(&mut self, _: f64) -> Result<(), SinkAbort> {
+        Ok(())
+    }
+    fn big_int(&mut self, _: &str) -> Result<(), SinkAbort> {
+        Ok(())
+    }
+    fn str(&mut self, _: &str) -> Result<(), SinkAbort> {
+        Ok(())
+    }
+    fn key(&mut self, _: &str) -> Result<(), SinkAbort> {
+        Ok(())
+    }
+    fn str_bytes(&mut self, _: &[u8]) -> Result<(), SinkAbort> {
+        Ok(())
+    }
+    fn mark(&self) -> usize {
+        0
+    }
+    fn begin_array(&mut self) -> Result<(), SinkAbort> {
+        self.depth += 1;
+        if self.depth > self.max_nesting {
+            return Err(SinkAbort::TooDeep);
+        }
+        Ok(())
+    }
+    fn begin_object(&mut self) -> Result<(), SinkAbort> {
+        self.depth += 1;
+        if self.depth > self.max_nesting {
+            return Err(SinkAbort::TooDeep);
+        }
+        Ok(())
+    }
+    fn end_array(&mut self, _: usize, _: usize) -> Result<(), SinkAbort> {
+        self.depth -= 1;
+        Ok(())
+    }
+    fn end_object(&mut self, _: usize, _: usize) -> Result<(), SinkAbort> {
+        self.depth -= 1;
+        Ok(())
+    }
+}

data/ext/nosj/src/state.rs

@@ -0,0 +1,89 @@
+//! Per-thread parser state and the GC-visible value-stack shadow.
+//!
+//! Pending VALUEs live on heap-allocated stacks that Ruby's GC can see
+//! through a wrapped handle object whose magnus-driven mark walks the
+//! live entries (the JSON gem's rvalue_stack design): precise marking
+//! of only `values.len()` slots, growing on demand so huge flat arrays
+//! (mesh.json) never overflow.
+
+use ahash::AHashMap;
+use magnus::typed_data::Obj;
+use magnus::{DataTypeFunctions, TypedData};
+use nosj::Buffers;
+use std::cell::RefCell;
+
+/// Everything a parse touches, allocated once per thread and reused:
+/// nosj's scratch buffers, the interned-key caches, and the GC-marked
+/// stacks.
+pub(crate) struct PullState {
+    pub(crate) bufs: Buffers,
+    pub(crate) keys: AHashMap<Box<str>, rb_sys::VALUE>,
+    /// Separate cache for symbolize_names mode: symbol and string VALUEs
+    /// must never share a map.
+    pub(crate) sym_keys: AHashMap<Box<str>, rb_sys::VALUE>,
+    /// Leaked once per thread; kept alive + GC-marked via the wrapped
+    /// handle.
+    pub(crate) vstack: Option<&'static mut VStackShadow>,
+    /// Marked shadow holding the cached key VALUEs; keys are kept alive by
+    /// this (collectable on epoch clear), NOT by per-key eternal GC pins.
+    pub(crate) key_shadow: Option<&'static mut VStackShadow>,
+}
+
+thread_local! {
+    pub(crate) static PULL_STATE: RefCell<PullState> = RefCell::new(PullState {
+        bufs: Buffers::new(),
+        keys: AHashMap::with_capacity(256),
+        sym_keys: AHashMap::new(),
+        vstack: None,
+        key_shadow: None,
+    });
+}
+
+/// GC-marked holder for pending VALUEs.
+pub(crate) struct VStackShadow {
+    pub(crate) values: Vec<rb_sys::VALUE>,
+}
+
+/// Ruby-side handle over a leaked shadow: magnus drives the GC mark
+/// through [`DataTypeFunctions::mark`] (its trampoline, not ours),
+/// pinning every pending VALUE with `rb_gc_mark` semantics. The class
+/// is defined (and made a private constant) at init.
+#[derive(TypedData)]
+#[magnus(class = "NOSJ::ValueStackShadow", mark)]
+pub(crate) struct ShadowHandle(*const VStackShadow);
+
+// SAFETY: the pointee is leaked for the process lifetime and each
+// handle stays with the thread that created it; the only cross-thread
+// access is the GC mark read, which runs at safepoints while the
+// owning thread is parked (the same contract the previous
+// rb_data_type_t dmark relied on).
+unsafe impl Send for ShadowHandle {}
+
+impl DataTypeFunctions for ShadowHandle {
+    fn mark(&self, marker: &magnus::gc::Marker) {
+        use magnus::rb_sys::FromRawValue;
+        // SAFETY: the shadow is leaked for the process lifetime, and
+        // GC marks at safepoints while the owning thread is not
+        // mutating the stack (the same contract the previous
+        // hand-written dmark relied on). Entries are live VALUEs
+        // pushed by the sinks.
+        let shadow = unsafe { &*self.0 };
+        for &v in &shadow.values {
+            marker.mark(unsafe { magnus::Value::from_raw(v) });
+        }
+    }
+}
+
+/// Create (once per thread) a leaked, GC-marked VStackShadow.
+pub(crate) fn ensure_marked_shadow(slot: &mut Option<&'static mut VStackShadow>) {
+    if slot.is_none() {
+        let ruby = magnus::Ruby::get().expect("called on a Ruby thread");
+        let shadow: &'static mut VStackShadow = Box::leak(Box::new(VStackShadow {
+            values: Vec::with_capacity(1024),
+        }));
+        let ptr = std::ptr::from_mut::<VStackShadow>(shadow).cast_const();
+        let handle: Obj<ShadowHandle> = ruby.obj_wrap(ShadowHandle(ptr));
+        ruby.gc_register_mark_object(handle);
+        *slot = Some(shadow);
+    }
+}

data/lib/nosj/json.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# Drop-in acceleration for the JSON module:
+#
+#   require "nosj/json"
+#
+# reroutes JSON.parse, JSON.generate, JSON.pretty_generate and JSON.dump
+# through NOSJ whenever the requested options fall within NOSJ's
+# supported set, and falls back to the original json implementation for
+# everything else (create_additions, object_class/array_class,
+# decimal_class, on_load procs, JSON::State instances, IO arguments).
+# Entry points built on JSON.parse (JSON.load, JSON.parse!,
+# JSON.load_file, JSON.unsafe_load) pick up the fast path automatically
+# and keep their exact legacy behavior when they need unsupported options
+# (JSON.load's create_additions default always takes the fallback).
+#
+# Exceptions from the fast path are re-raised as the JSON classes
+# (JSON::ParserError, JSON::GeneratorError, JSON::NestingError), so
+# existing rescue clauses keep working. Parse error MESSAGES are
+# NOSJ's (byte offsets rather than the gem's phrasing).
+#
+# Not rerouted: obj.to_json (core extensions drive the gem's generator
+# directly), and objects with a custom to_json inside a rerouted
+# generate receive no State argument (documented NOSJ divergence).
+
+require "json"
+require "nosj"
+
+module NOSJ
+  # Implementation detail of `require "nosj/json"`.
+  # @private
+  module JSONDropIn
+    PARSE_OPTS = %i[symbolize_names freeze max_nesting allow_nan
+      allow_trailing_comma].freeze
+    GENERATE_OPTS = %i[indent space space_before object_nl array_nl
+      max_nesting allow_nan ascii_only script_safe
+      escape_slash strict depth
+      buffer_initial_length].freeze
+
+    module_function
+
+    # The fast path handles nil or a plain Hash whose every key NOSJ
+    # implements; anything else (JSON::State, exotic options, string
+    # keys) belongs to the original implementation.
+    def supported?(opts, allowed)
+      return true if opts.nil?
+      return false unless opts.instance_of?(Hash)
+      opts.each_key { |k| return false unless allowed.include?(k) }
+      true
+    end
+
+    def parse(source, opts)
+      NOSJ.parse(source, opts)
+    rescue RuntimeError => e
+      raise ::JSON::ParserError, e.message
+    end
+
+    def generate(obj, opts, pretty)
+      pretty ? NOSJ.pretty_generate(obj, opts) : NOSJ.generate(obj, opts)
+    rescue NOSJ::NestingError => e
+      raise ::JSON::NestingError, e.message
+    rescue NOSJ::GeneratorError => e
+      raise ::JSON::GeneratorError, e.message
+    end
+  end
+end
+
+# Reopened by `require "nosj/json"` to reroute the module functions
+# through NOSJ; behavior is documented on the require and in the
+# README, not here.
+# @private
+module JSON
+  class << self
+    unless method_defined?(:nosj_original_parse) || private_method_defined?(:nosj_original_parse)
+      alias_method :nosj_original_parse, :parse
+      alias_method :nosj_original_generate, :generate
+      alias_method :nosj_original_pretty_generate, :pretty_generate
+      alias_method :nosj_original_dump, :dump
+
+      def parse(source, opts = nil)
+        if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::PARSE_OPTS)
+          NOSJ::JSONDropIn.parse(source, opts)
+        else
+          nosj_original_parse(source, opts)
+        end
+      end
+
+      def generate(obj, opts = nil)
+        if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::GENERATE_OPTS)
+          NOSJ::JSONDropIn.generate(obj, opts, false)
+        else
+          nosj_original_generate(obj, opts)
+        end
+      end
+
+      def pretty_generate(obj, opts = nil)
+        if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::GENERATE_OPTS)
+          NOSJ::JSONDropIn.generate(obj, opts, true)
+        else
+          nosj_original_pretty_generate(obj, opts)
+        end
+      end
+
+      def dump(obj, an_io = nil, limit = nil, kwargs = nil)
+        # Fast path for the common shapes, dump(obj) and dump(obj, opts
+        # hash), mirroring the gem: dump defaults merged under the
+        # user's options, NestingError surfaced as ArgumentError. IO and
+        # limit arguments take the original implementation.
+        if limit.nil? && kwargs.nil? && (an_io.nil? || an_io.instance_of?(Hash))
+          opts = _dump_default_options
+          opts = opts.merge(an_io) if an_io
+          if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::GENERATE_OPTS)
+            begin
+              return NOSJ::JSONDropIn.generate(obj, opts, false)
+            rescue ::JSON::NestingError
+              raise ArgumentError, "exceed depth limit"
+            end
+          end
+        end
+        nosj_original_dump(obj, an_io, limit, kwargs)
+      end
+    end
+  end
+end

data/lib/nosj/multi_json.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# MultiJson adapter:
+#
+#   require "nosj/multi_json"
+#   MultiJson.use NOSJ::MultiJsonAdapter
+#
+# Anything speaking MultiJson (Faraday middleware and friends) then
+# parses and generates through NOSJ.
+
+require "json"
+require "multi_json"
+require "multi_json/adapter"
+require "nosj"
+
+module NOSJ
+  # MultiJson adapter routing +MultiJson.load+/+dump+ through nosj.
+  #
+  # multi_json 2.x renamed its namespace MultiJson -> MultiJSON; the
+  # adapter inherits from whichever this installation defines.
+  #
+  # @example
+  #   require "nosj/multi_json"
+  #   MultiJson.use NOSJ::MultiJsonAdapter
+  class MultiJsonAdapter < (defined?(::MultiJSON) ? ::MultiJSON::Adapter : ::MultiJson::Adapter)
+    # MultiJson wraps whatever the adapter's ParseError names.
+    ParseError = ::JSON::ParserError
+
+    SYMBOLIZE = {symbolize_names: true}.freeze
+    private_constant :SYMBOLIZE
+
+    # @param string [String] the JSON document
+    # @param options [Hash] multi_json load options; +symbolize_keys+
+    #   arrives normalized as +symbolize_names+
+    # @return [Object] the parsed value tree
+    # @raise [JSON::ParserError] when the document is malformed
+    def load(string, options = {})
+      ::NOSJ.parse(string, options[:symbolize_names] ? SYMBOLIZE : nil)
+    rescue RuntimeError => e
+      raise ParseError, e.message
+    end
+
+    # @param object [Object] the value tree to serialize
+    # @param options [Hash] multi_json dump options; +pretty+ selects
+    #   pretty-printing
+    # @return [String] the JSON document
+    def dump(object, options = {})
+      options[:pretty] ? ::NOSJ.pretty_generate(object) : ::NOSJ.generate(object)
+    end
+  end
+end

data/lib/nosj/native.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Precompiled platform gems ship one extension per Ruby minor under
+# lib/nosj/<major.minor>/; the source gem compiles straight to
+# lib/nosj/nosj.<dlext>.
+begin
+  ruby_version = RUBY_VERSION[/\d+\.\d+/]
+  require_relative "#{ruby_version}/nosj"
+rescue LoadError
+  require_relative "nosj"
+end

data/lib/nosj/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module NOSJ
+  # The gem version.
+  VERSION = "0.1.0"
+end