nosj 0.1.0

data/ext/nosj/src/parse.rs

@@ -0,0 +1,211 @@
+//! Whole-document entry points: `NOSJ.parse` (fused cursor),
+//! `NOSJ.valid?` (null sink), and the unregistered GVL-releasing
+//! indexed parse, plus the shared option decoding, input gating, and
+//! drive-result mapping they all use.
+
+use magnus::rb_sys::{AsRawValue, FromRawValue};
+use magnus::{Error, RString, Ruby, Value};
+
+use crate::sink::{NullSink, RubyValueSink, SinkAbort, MAX_NESTING};
+use crate::state::{ensure_marked_shadow, PullState, PULL_STATE};
+
+#[cold]
+pub(crate) fn err(ruby: &Ruby, msg: String) -> Error {
+    Error::new(ruby.exception_runtime_error(), msg)
+}
+
+/// Validate that `data` is UTF-8 (or US-ASCII) with intact coderange and
+/// hand out its byte slice.
+pub(crate) fn utf8_input<'a>(ruby: &Ruby, data: &'a RString) -> Result<&'a [u8], Error> {
+    let raw = data.as_raw();
+    unsafe {
+        let enc = rb_sys::rb_enc_get_index(raw);
+        if enc != rb_sys::rb_utf8_encindex() && enc != rb_sys::rb_usascii_encindex() {
+            return Err(err(ruby, "input must be UTF-8 encoded".into()));
+        }
+        if rb_sys::rb_enc_str_coderange(raw)
+            == rb_sys::ruby_coderange_type::RUBY_ENC_CODERANGE_BROKEN as std::os::raw::c_int
+        {
+            return Err(err(ruby, "input is not valid UTF-8".into()));
+        }
+        Ok(data.as_slice())
+    }
+}
+
+/// JSON.parse-compatible options, decoded once from the Ruby hash and
+/// shared by every entry point that materializes (or validates) values.
+#[derive(Clone, Copy)]
+pub(crate) struct ParseNativeOpts {
+    pub(crate) symbolize: bool,
+    pub(crate) freeze: bool,
+    pub(crate) max_nesting: usize,
+    pub(crate) popts: nosj::ParseOptions,
+}
+
+impl Default for ParseNativeOpts {
+    fn default() -> Self {
+        Self {
+            symbolize: false,
+            freeze: false,
+            max_nesting: MAX_NESTING,
+            popts: nosj::ParseOptions::default(),
+        }
+    }
+}
+
+/// Decode a JSON.parse-compatible options hash: symbolize_names, freeze,
+/// max_nesting, allow_nan, allow_trailing_comma. Unsupported gem options
+/// (object_class, array_class, decimal_class, create_additions) raise.
+pub(crate) fn parse_native_opts(ruby: &Ruby, opts: Value) -> Result<ParseNativeOpts, Error> {
+    use magnus::value::ReprValue;
+    use magnus::RHash;
+
+    let mut out = ParseNativeOpts::default();
+    if opts.is_nil() {
+        return Ok(out);
+    }
+    let h = RHash::from_value(opts)
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), "options must be a Hash"))?;
+
+    let truthy = |name: &str| -> bool {
+        h.get(ruby.to_symbol(name))
+            .is_some_and(|v: Value| v.to_bool())
+    };
+
+    out.symbolize = truthy("symbolize_names");
+    out.freeze = truthy("freeze");
+    out.popts.allow_nan = truthy("allow_nan");
+    out.popts.allow_trailing_comma = truthy("allow_trailing_comma");
+
+    if let Some(mn) = h.get(ruby.to_symbol("max_nesting")) {
+        out.max_nesting =
+            if mn.is_nil() || mn.to_bool() && magnus::Integer::from_value(mn).is_none() {
+                MAX_NESTING // nil / true: gem default
+            } else if !mn.to_bool() {
+                usize::MAX // false: unlimited
+            } else {
+                magnus::Integer::from_value(mn)
+                    .and_then(|i| i.to_u64().ok())
+                    .map_or(MAX_NESTING, |n| n as usize)
+            };
+    }
+
+    for unsupported in [
+        "object_class",
+        "array_class",
+        "decimal_class",
+        "create_additions",
+    ] {
+        if truthy(unsupported) {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("NOSJ.parse does not support the {unsupported} option"),
+            ));
+        }
+    }
+    Ok(out)
+}
+
+/// Pop the root value off the sink stack, or map a drive failure onto
+/// the gem's exceptions. Shared by every driver.
+fn finish_drive(
+    ruby: &Ruby,
+    result: Result<(), nosj::DriveError<SinkAbort>>,
+    stack: &mut Vec<rb_sys::VALUE>,
+    max_nesting: usize,
+) -> Result<Value, Error> {
+    match result {
+        Ok(()) => {
+            let raw = stack
+                .pop()
+                .unwrap_or(rb_sys::special_consts::Qnil as rb_sys::VALUE);
+            Ok(unsafe { Value::from_raw(raw) })
+        }
+        Err(nosj::DriveError::Sink(SinkAbort::Overflow)) => {
+            Err(err(ruby, "document too large".into()))
+        }
+        Err(nosj::DriveError::Sink(SinkAbort::BadBigint)) => {
+            Err(err(ruby, "invalid bignum".into()))
+        }
+        Err(nosj::DriveError::Sink(SinkAbort::TooDeep)) => Err(err(
+            ruby,
+            format!("nesting of {} is too deep", max_nesting.saturating_add(1)),
+        )),
+        Err(nosj::DriveError::Parse(e)) => Err(err(ruby, e.to_string())),
+    }
+}
+
+/// Drive the fused cursor over `input`, building Ruby values through the
+/// shared thread-local sink machinery. `input` must be valid UTF-8 (see
+/// [`utf8_input`]).
+pub(crate) fn materialize(ruby: &Ruby, input: &[u8], o: &ParseNativeOpts) -> Result<Value, Error> {
+    PULL_STATE.with(|cell| {
+        let mut state = cell.borrow_mut();
+        ensure_marked_shadow(&mut state.vstack);
+        ensure_marked_shadow(&mut state.key_shadow);
+
+        let PullState {
+            bufs,
+            keys,
+            sym_keys,
+            vstack,
+            key_shadow,
+            ..
+        } = &mut *state;
+        let stack = &mut vstack.as_mut().unwrap().values;
+        stack.clear();
+
+        let mut sink = RubyValueSink {
+            stack,
+            keys: if o.symbolize { sym_keys } else { keys },
+            key_shadow: key_shadow.as_deref_mut().unwrap(),
+            depth: 0,
+            symbolize: o.symbolize,
+            freeze: o.freeze,
+            max_nesting: o.max_nesting,
+        };
+
+        // Safety: callers verified UTF-8 (coderange or nosj slice).
+        let result = unsafe { nosj::parse_utf8_unchecked_with(input, bufs, &mut sink, o.popts) };
+        finish_drive(ruby, result, sink.stack, o.max_nesting)
+    })
+}
+
+/// JSON.parse-compatible entry (see [`parse_native_opts`] for options).
+pub fn parse_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    data: RString,
+    opts: Value,
+) -> Result<Value, Error> {
+    let o = parse_native_opts(ruby, opts)?;
+    let input = utf8_input(ruby, &data)?;
+    materialize(ruby, input, &o)
+}
+
+/// `NOSJ.valid?(source, opts)` returns true iff `NOSJ.parse` would
+/// succeed under the same options. Parse refusals (malformed JSON, bad
+/// encoding, too-deep nesting) return false; option and argument-type
+/// errors still raise exactly like `parse`.
+pub fn valid_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    data: RString,
+    opts: Value,
+) -> Result<bool, Error> {
+    let o = parse_native_opts(ruby, opts)?;
+    let Ok(input) = utf8_input(ruby, &data) else {
+        return Ok(false);
+    };
+    let ok = PULL_STATE.with(|cell| {
+        let mut state = cell.borrow_mut();
+        let mut sink = NullSink {
+            depth: 0,
+            max_nesting: o.max_nesting,
+        };
+        // Safety: coderange verified by utf8_input.
+        unsafe { nosj::parse_utf8_unchecked_with(input, &mut state.bufs, &mut sink, o.popts) }
+            .is_ok()
+    });
+    Ok(ok)
+}

data/ext/nosj/src/pointer.rs

@@ -0,0 +1,190 @@
+//! Partial parsing: `NOSJ.dig`, `NOSJ.at_pointer`, and their batch
+//! forms. Pointers resolve against the raw document through the nosj
+//! crate's cursor-mode skipper; only the matched subtree materializes,
+//! through the same sink machinery as a full parse.
+
+use magnus::{Error, RString, Ruby, Value};
+
+use crate::parse::{err, materialize, parse_native_opts, utf8_input, ParseNativeOpts};
+use crate::state::PULL_STATE;
+
+/// Resolve one JSON Pointer against `data`, materializing the matched
+/// subtree; `nil` when the pointer misses.
+fn at_pointer_impl(
+    ruby: &Ruby,
+    data: RString,
+    pointer: &str,
+    o: &ParseNativeOpts,
+) -> Result<Value, Error> {
+    use magnus::value::ReprValue;
+    let input = utf8_input(ruby, &data)?;
+    // Resolve first (one PULL_STATE borrow), then materialize (a fresh
+    // borrow); the resolved slice borrows `input`, not the buffers.
+    let resolved = PULL_STATE.with(|cell| {
+        let mut state = cell.borrow_mut();
+        // Safety: coderange verified above.
+        unsafe { nosj::pointer_utf8_unchecked(input, pointer, &mut state.bufs) }
+    });
+    match resolved {
+        Ok(None) => Ok(ruby.qnil().as_value()),
+        Ok(Some(slice)) => materialize(ruby, slice.as_bytes(), o),
+        Err(e) if matches!(e.kind, nosj::ErrorKind::InvalidPointer) => {
+            Err(Error::new(ruby.exception_arg_error(), e.to_string()))
+        }
+        Err(e) => Err(err(ruby, e.to_string())),
+    }
+}
+
+/// `NOSJ.at_pointer(source, "/a/b/0", opts)`: pointer lookup; the
+/// matched subtree materializes under the same options as `parse`.
+pub fn at_pointer_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    data: RString,
+    pointer: RString,
+    opts: Value,
+) -> Result<Value, Error> {
+    let o = parse_native_opts(ruby, opts)?;
+    let ptr = pointer.to_string()?;
+    at_pointer_impl(ruby, data, &ptr, &o)
+}
+
+/// Convert one dig path (String/Symbol keys, Integer indices) into a
+/// JSON Pointer, `~`/`/` escaped. `None` = a negative index: no pointer
+/// equivalent, the path resolves to `nil` by definition.
+fn path_to_pointer(ruby: &Ruby, path: magnus::RArray) -> Result<Option<String>, Error> {
+    fn push_escaped_token(ptr: &mut String, key: &str) {
+        ptr.push('/');
+        for c in key.chars() {
+            match c {
+                '~' => ptr.push_str("~0"),
+                '/' => ptr.push_str("~1"),
+                c => ptr.push(c),
+            }
+        }
+    }
+
+    let mut ptr = String::new();
+    for i in 0..path.len() {
+        let item: Value = path.entry(i as isize)?;
+        if let Some(int) = magnus::Integer::from_value(item) {
+            let idx = int.to_i64()?;
+            if idx < 0 {
+                return Ok(None);
+            }
+            ptr.push('/');
+            ptr.push_str(&idx.to_string());
+        } else if let Some(s) = RString::from_value(item) {
+            push_escaped_token(&mut ptr, &s.to_string()?);
+        } else if let Some(sym) = magnus::Symbol::from_value(item) {
+            push_escaped_token(&mut ptr, &sym.name()?);
+        } else {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                "path elements must be Strings, Symbols, or Integers",
+            ));
+        }
+    }
+    Ok(Some(ptr))
+}
+
+/// `NOSJ.dig(source, *path)`: Hash#dig-shaped partial parsing.
+/// Negative indices resolve to `nil` (JSON Pointer has no equivalent).
+pub fn dig_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    data: RString,
+    path: magnus::RArray,
+) -> Result<Value, Error> {
+    use magnus::value::ReprValue;
+    match path_to_pointer(ruby, path)? {
+        Some(ptr) => at_pointer_impl(ruby, data, &ptr, &ParseNativeOpts::default()),
+        None => Ok(ruby.qnil().as_value()),
+    }
+}
+
+/// Resolve many pointers in ONE forward pass (`nosj::pointers`: the
+/// walk descends only into subtrees some pointer still needs, so a batch
+/// costs about its single deepest query), then materialize each hit.
+/// `None` entries (negative dig indices) come back as `nil` without ever
+/// reaching the resolver.
+fn at_pointers_impl(
+    ruby: &Ruby,
+    data: RString,
+    pointers: &[Option<String>],
+    o: &ParseNativeOpts,
+) -> Result<Value, Error> {
+    use magnus::value::ReprValue;
+
+    let input = utf8_input(ruby, &data)?;
+    let live: Vec<&str> = pointers.iter().flatten().map(String::as_str).collect();
+
+    // Resolve first (one PULL_STATE borrow); the resolved slices borrow
+    // `input`, not the buffers, so materializing can re-borrow freely.
+    let resolved = PULL_STATE.with(|cell| {
+        let mut state = cell.borrow_mut();
+        // Safety: coderange verified by utf8_input.
+        unsafe { nosj::pointers_utf8_unchecked(input, &live, &mut state.bufs) }
+    });
+    let mut hits = match resolved {
+        Ok(hits) => hits.into_iter(),
+        Err(e) if matches!(e.kind, nosj::ErrorKind::InvalidPointer) => {
+            return Err(Error::new(ruby.exception_arg_error(), e.to_string()));
+        }
+        Err(e) => return Err(err(ruby, e.to_string())),
+    };
+
+    let out = ruby.ary_new_capa(pointers.len());
+    for ptr in pointers {
+        let hit = if ptr.is_some() {
+            hits.next().flatten()
+        } else {
+            None
+        };
+        match hit {
+            Some(slice) => out.push(materialize(ruby, slice.as_bytes(), o)?)?,
+            None => out.push(ruby.qnil())?,
+        }
+    }
+    Ok(out.as_value())
+}
+
+/// `NOSJ.at_pointers(source, pointers, opts)`: batch pointer lookup,
+/// positionally aligned results.
+pub fn at_pointers_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    data: RString,
+    pointers: magnus::RArray,
+    opts: Value,
+) -> Result<Value, Error> {
+    let o = parse_native_opts(ruby, opts)?;
+    let mut ptrs: Vec<Option<String>> = Vec::with_capacity(pointers.len());
+    for i in 0..pointers.len() {
+        let item: Value = pointers.entry(i as isize)?;
+        let s = RString::from_value(item)
+            .ok_or_else(|| Error::new(ruby.exception_arg_error(), "pointers must be Strings"))?;
+        ptrs.push(Some(s.to_string()?));
+    }
+    at_pointers_impl(ruby, data, &ptrs, &o)
+}
+
+/// `NOSJ.dig_many(source, paths, opts)`: batch dig, one resolver
+/// pass for all paths.
+pub fn dig_many_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    data: RString,
+    paths: magnus::RArray,
+    opts: Value,
+) -> Result<Value, Error> {
+    let o = parse_native_opts(ruby, opts)?;
+    let mut ptrs: Vec<Option<String>> = Vec::with_capacity(paths.len());
+    for i in 0..paths.len() {
+        let item: Value = paths.entry(i as isize)?;
+        let path = magnus::RArray::from_value(item)
+            .ok_or_else(|| Error::new(ruby.exception_arg_error(), "each path must be an Array"))?;
+        ptrs.push(path_to_pointer(ruby, path)?);
+    }
+    at_pointers_impl(ruby, data, &ptrs, &o)
+}