nosj 0.2.0 → 0.3.1

data/ext/nosj/fuzz/src/prelude.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+# Differential checks for the extension fuzz targets. Only the native
+# layer is loaded (Init_nosj, no lib/nosj.rb), so the error classes the
+# extension looks up by name are defined here first.
+module NOSJ
+  class Error < StandardError; end
+  class ParserError < Error; end
+  class GeneratorError < Error; end
+  class NestingError < Error; end
+  class PatchError < Error; end
+end
+
+module NOSJFuzz
+  # A reference-side rejection: the case must fail natively too.
+  RefFail = Class.new(StandardError)
+
+  PARSE_FAIL = [NOSJ::ParserError, NOSJ::NestingError].freeze
+  EDIT_FAIL = (PARSE_FAIL + [NOSJ::PatchError, NOSJ::GeneratorError,
+    KeyError, ArgumentError, TypeError]).freeze
+  PRETTY = {indent: "  ", space: " ", object_nl: "\n", array_nl: "\n"}.freeze
+  # A copy op can double the document (copy root into a child), so a
+  # long op list can grow it exponentially; keep runs tractable.
+  MAX_PATCH_OPS = 12
+
+  module_function
+
+  def utf8(bytes) = bytes.dup.force_encoding(Encoding::UTF_8)
+
+  def try_parse(s, opts = nil)
+    [:ok, NOSJ.parse_native(s, opts)]
+  rescue *PARSE_FAIL
+    [:err, nil]
+  end
+
+  # --- reformat: minify/reformat vs parse-then-generate ---------------
+
+  def reformat_case(bytes)
+    s = utf8(bytes)
+    status, value = try_parse(s)
+
+    unless NOSJ.valid_native(s, nil) == (status == :ok)
+      raise "valid? disagrees with parse on acceptance"
+    end
+    stats_ok = begin
+      NOSJ.stats_native(s, nil)
+      true
+    rescue *PARSE_FAIL
+      false
+    end
+    raise "stats disagrees with parse on acceptance" unless stats_ok == (status == :ok)
+
+    min_status, min = begin
+      [:ok, NOSJ.reformat_native(s, nil)]
+    rescue *PARSE_FAIL
+      [:err, nil]
+    rescue NOSJ::GeneratorError
+      [:generator, nil]
+    end
+
+    if status == :err
+      # The pipe may abort with GeneratorError (lone-surrogate key,
+      # non-finite float) before the parser reaches whatever made the
+      # whole document unparseable; any refusal is a refusal.
+      raise "reformat accepted what parse refused" unless [:err, :generator].include?(min_status)
+      return
+    end
+    if min_status == :generator
+      # On a document parse accepts, only an overflow-to-Infinity
+      # float (1e999, a 300-digit integer with a small exponent, maybe
+      # hidden behind a duplicate key parse would discard) or a
+      # lone-surrogate object key may abort the pipe. Rerunning with
+      # allow_nan separates them: it lifts the float refusal but not
+      # the key refusal, and the key requires a \u escape.
+      begin
+        NOSJ.reformat_native(s, {allow_nan: true})
+      rescue NOSJ::GeneratorError
+        raise "GeneratorError without a \\u escape in source" unless s.include?("\\u")
+      end
+      return
+    end
+    raise "reformat refused what parse accepted" unless min_status == :ok
+
+    reparsed = stage("reparse minify output #{min.inspect[0, 200]}") do
+      NOSJ.parse_native(min, nil)
+    end
+    raise "minify does not round-trip: #{min.inspect[0, 200]}" unless reparsed.eql?(value)
+    raise "minify is not idempotent" unless stage("re-minify") {
+      NOSJ.reformat_native(min, nil)
+    } == min
+    pretty = stage("pretty") { NOSJ.reformat_native(s, PRETTY) }
+    raise "pretty does not round-trip" unless stage("reparse pretty") {
+      NOSJ.parse_native(pretty, nil)
+    }.eql?(value)
+    nil
+  end
+
+  # Rebrand an exception from a must-succeed stage with its context;
+  # these are harness violations, not expected refusals.
+  def stage(name)
+    yield
+  rescue => e
+    raise "#{name} failed: #{e.class}: #{e.message}"
+  end
+
+  # --- lines: each_line vs one parse per line -------------------------
+
+  def lines_case(bytes)
+    s = utf8(bytes)
+    yielded = []
+    status = begin
+      NOSJ.each_line_native(s, nil) { |v| yielded << v }
+      :ok
+    rescue *PARSE_FAIL
+      :err
+    end
+
+    unless s.valid_encoding?
+      raise "each_line accepted invalid UTF-8" unless status == :err
+      raise "each_line yielded before the encoding gate" unless yielded.empty?
+      return
+    end
+
+    reference = []
+    ref_status = :ok
+    s.split("\n", -1).each do |line|
+      next if line.match?(/\A[ \t\r]*\z/)
+      line_status, value = try_parse(line)
+      if line_status == :err
+        ref_status = :err
+        break
+      end
+      reference << value
+    end
+
+    unless status == ref_status
+      raise "acceptance: each_line #{status}, per-line parse #{ref_status}"
+    end
+    # On error the values yielded before the bad line must still match.
+    raise "yielded values diverge from per-line parses" unless yielded.eql?(reference)
+
+    if status == :ok && !yielded.empty?
+      begin
+        ndjson = NOSJ.generate_lines_native(yielded, nil)
+      rescue NOSJ::GeneratorError
+        return # WTF-8 strings (lone surrogates) are not generable
+      end
+      back = []
+      NOSJ.each_line_native(ndjson, nil) { |v| back << v }
+      raise "generate_lines does not round-trip" unless back.eql?(yielded)
+    end
+    nil
+  end
+
+  # --- patch/splice: raw-byte editing vs tree editing -----------------
+
+  # Input is "document \0 spec"; a spec parsing to an object fuzzes
+  # splice (pointer => value), an array fuzzes RFC 6902 patch.
+  #
+  # The reference tree parses under the default nesting cap, so
+  # deeper-than-100 documents are exercised for crashes only, like
+  # malformed ones: resolution scans just the bytes some pointer needs
+  # (documented crate semantics), so the native side may legitimately
+  # succeed where whole-document parsing refuses.
+  def patch_case(bytes)
+    doc_bytes, sep, spec_bytes = bytes.partition("\0")
+    return if sep.empty?
+    doc = utf8(doc_bytes)
+    spec_status, spec = try_parse(utf8(spec_bytes))
+    return unless spec_status == :ok
+    # Replacement values with broken encoding (lone surrogates) raise
+    # GeneratorError on insertion; the reference cannot mirror that.
+    return unless deep_valid_encoding?(spec)
+
+    tree_status, tree = try_parse(doc)
+    # Duplicate keys: raw-byte resolution sees the first occurrence,
+    # tree materialization keeps the last; the two sides cannot agree.
+    if tree_status == :ok && NOSJ.stats_native(doc, nil)[:keys] != count_keys(tree)
+      return
+    end
+
+    case spec
+    when Hash
+      splice_case(doc, tree_status, tree, spec)
+    when Array
+      return if spec.length > MAX_PATCH_OPS
+      rfc6902_case(doc, tree_status, tree, spec)
+    end
+    nil
+  end
+
+  def splice_case(doc, tree_status, tree, edits)
+    native_status, result = begin
+      [:ok, NOSJ.splice_native(doc, edits, nil)]
+    rescue *EDIT_FAIL
+      [:err, nil]
+    end
+    return unless tree_status == :ok
+
+    ref_status, ref = begin
+      [:ok, ref_splice(tree, edits)]
+    rescue RefFail
+      [:err, nil]
+    end
+    unless native_status == ref_status
+      raise "splice acceptance: native #{native_status}, reference #{ref_status}"
+    end
+    return unless native_status == :ok
+    got = NOSJ.parse_native(result, {max_nesting: false})
+    raise "splice result diverges from reference" unless got.eql?(ref)
+  end
+
+  def rfc6902_case(doc, tree_status, tree, ops)
+    native_status, result = begin
+      [:ok, NOSJ.patch_native(doc, ops, nil)]
+    rescue *EDIT_FAIL
+      [:err, nil]
+    end
+    return unless tree_status == :ok
+
+    ref_status, ref = begin
+      [:ok, ref_patch(tree, ops)]
+    rescue RefFail
+      [:err, nil]
+    end
+    unless native_status == ref_status
+      raise "patch acceptance: native #{native_status}, reference #{ref_status}"
+    end
+    return unless native_status == :ok
+    got = NOSJ.parse_native(result, {max_nesting: false})
+    raise "patch result diverges from reference" unless got.eql?(ref)
+  end
+
+  # --- the pure-Ruby reference implementations ------------------------
+
+  def ref_splice(tree, edits)
+    token_lists = edits.keys.map { |ptr| ptr_tokens(ptr) }
+    token_lists.combination(2) do |a, b|
+      short, long = (a.length <= b.length) ? [a, b] : [b, a]
+      raise RefFail if long[0, short.length] == short
+    end
+    box = [tree]
+    edits.each_value.with_index do |value, i|
+      toks = token_lists[i]
+      if toks.empty?
+        box[0] = value
+      else
+        parent = ref_resolve(box[0], toks[0..-2])
+        case parent
+        when Hash
+          raise RefFail unless parent.key?(toks[-1])
+          parent[toks[-1]] = value
+        when Array
+          parent[strict_index(toks[-1], parent.size)] = value
+        else
+          raise RefFail
+        end
+      end
+    end
+    box[0]
+  end
+
+  def ref_patch(tree, ops)
+    box = [tree]
+    ops.each do |op|
+      raise RefFail unless op.is_a?(Hash)
+      name = op["op"]
+      raise RefFail unless name.is_a?(String)
+      path = op["path"]
+      raise RefFail unless path.is_a?(String)
+      case name
+      when "add" then ref_add(box, ptr_tokens(path), fetch_value(op))
+      when "replace" then ref_replace(box, ptr_tokens(path), fetch_value(op))
+      when "remove" then ref_remove(box, ptr_tokens(path))
+      when "move"
+        from = op["from"]
+        raise RefFail unless from.is_a?(String)
+        # The native side short-circuits these before validating the
+        # pointers, in this order; mirror it exactly.
+        next if path == from
+        raise RefFail if path.start_with?("#{from}/") || from.empty?
+        from_toks = ptr_tokens(from)
+        moved = ref_resolve(box[0], from_toks)
+        ref_remove(box, from_toks)
+        ref_add(box, ptr_tokens(path), moved)
+      when "copy"
+        from = op["from"]
+        raise RefFail unless from.is_a?(String)
+        ref_add(box, ptr_tokens(path), deep_dup(ref_resolve(box[0], ptr_tokens(from))))
+      when "test"
+        raise RefFail unless ref_resolve(box[0], ptr_tokens(path)) == fetch_value(op)
+      else
+        raise RefFail
+      end
+    end
+    box[0]
+  end
+
+  def ptr_tokens(ptr)
+    return [] if ptr.empty?
+    raise RefFail unless ptr.start_with?("/")
+    # RFC 6901 unescape order: ~1 before ~0, matching the native side.
+    ptr.split("/", -1).drop(1).map { |t| t.gsub("~1", "/").gsub("~0", "~") }
+  end
+
+  def strict_index(token, size, insert: false)
+    raise RefFail unless token.match?(/\A(?:0|[1-9][0-9]*)\z/)
+    i = token.to_i
+    in_range = i < size || (insert && i == size)
+    raise RefFail unless in_range
+    i
+  end
+
+  def ref_resolve(node, toks)
+    toks.each do |t|
+      case node
+      when Hash
+        raise RefFail unless node.key?(t)
+        node = node[t]
+      when Array
+        node = node[strict_index(t, node.size)]
+      else
+        raise RefFail
+      end
+    end
+    node
+  end
+
+  def ref_add(box, toks, value)
+    return box[0] = value if toks.empty?
+    parent = ref_resolve(box[0], toks[0..-2])
+    case parent
+    when Hash
+      parent[toks[-1]] = value
+    when Array
+      i = (toks[-1] == "-") ? parent.size : strict_index(toks[-1], parent.size, insert: true)
+      parent.insert(i, value)
+    else
+      raise RefFail
+    end
+  end
+
+  def ref_replace(box, toks, value)
+    return box[0] = value if toks.empty?
+    parent = ref_resolve(box[0], toks[0..-2])
+    case parent
+    when Hash
+      raise RefFail unless parent.key?(toks[-1])
+      parent[toks[-1]] = value
+    when Array
+      parent[strict_index(toks[-1], parent.size)] = value
+    else
+      raise RefFail
+    end
+  end
+
+  def ref_remove(box, toks)
+    raise RefFail if toks.empty?
+    parent = ref_resolve(box[0], toks[0..-2])
+    case parent
+    when Hash
+      raise RefFail unless parent.key?(toks[-1])
+      parent.delete(toks[-1])
+    when Array
+      parent.delete_at(strict_index(toks[-1], parent.size))
+    else
+      raise RefFail
+    end
+  end
+
+  def fetch_value(op)
+    raise RefFail unless op.key?("value")
+    op["value"]
+  end
+
+  def deep_dup(v)
+    case v
+    when Hash then v.transform_values { |e| deep_dup(e) }
+    when Array then v.map { |e| deep_dup(e) }
+    else v
+    end
+  end
+
+  def deep_valid_encoding?(v)
+    case v
+    when String then v.valid_encoding?
+    when Array then v.all? { |e| deep_valid_encoding?(e) }
+    when Hash then v.all? { |k, e| deep_valid_encoding?(k) && deep_valid_encoding?(e) }
+    else true
+    end
+  end
+
+  def count_keys(v)
+    case v
+    when Hash then v.size + v.sum { |_, e| count_keys(e) }
+    when Array then v.sum { |e| count_keys(e) }
+    else 0
+    end
+  end
+end

data/ext/nosj/src/errors.rs

@@ -0,0 +1,171 @@
+//! Parse-side exception raising. Malformed documents raise
+//! `NOSJ::ParserError` carrying the failure position (`#byte_offset`,
+//! `#line`, `#column`) and a caret snippet (`#snippet`); too-deep
+//! nesting raises `NOSJ::NestingError`, matching gem json's classes.
+//!
+//! Everything here runs only when a parse has already failed: the
+//! position pass over the source and the exception construction cost
+//! nothing on the happy path, and the accessors on the Ruby side are
+//! plain ivar reads.
+
+use magnus::value::ReprValue;
+use magnus::{Class, Error, ExceptionClass, Module, Object, RModule, RObject, Ruby};
+
+/// Look up an exception class under NOSJ, falling back to RuntimeError
+/// if the Ruby layer has not defined it (only possible when the native
+/// extension is loaded without lib/nosj.rb).
+pub(crate) fn nosj_exception(ruby: &Ruby, name: &str) -> ExceptionClass {
+    let lookup = || -> Result<ExceptionClass, Error> {
+        let m: RModule = ruby.define_module("NOSJ")?;
+        m.const_get(name)
+    };
+    lookup().unwrap_or_else(|_| ruby.exception_runtime_error())
+}
+
+/// NOSJ::ParserError without position info (encoding refusals and
+/// other failures that have no meaningful offset).
+#[cold]
+pub(crate) fn parser_error(ruby: &Ruby, msg: String) -> Error {
+    Error::new(nosj_exception(ruby, "ParserError"), msg)
+}
+
+/// NOSJ::NestingError (parse side: message parity with gem json, which
+/// raises JSON::NestingError when max_nesting is exceeded).
+#[cold]
+pub(crate) fn nesting_error(ruby: &Ruby, msg: String) -> Error {
+    Error::new(nosj_exception(ruby, "NestingError"), msg)
+}
+
+/// Plain RuntimeError, for failures that are not parse errors (the
+/// unmappable-I/O fallback).
+#[cold]
+pub(crate) fn runtime_error(ruby: &Ruby, msg: String) -> Error {
+    Error::new(ruby.exception_runtime_error(), msg)
+}
+
+/// NOSJ::ParserError enriched with the failure position: `offset` is a
+/// byte offset into `source` (the full document, so positions stay
+/// absolute even when the failing parse ran over a subtree slice).
+#[cold]
+pub(crate) fn parser_error_at(ruby: &Ruby, source: &[u8], offset: usize, msg: String) -> Error {
+    let class = nosj_exception(ruby, "ParserError");
+    let loc = locate(source, offset);
+    let Ok(exc) = class.new_instance((msg.as_str(),)) else {
+        return Error::new(class, msg);
+    };
+    // Exception instances are plain T_OBJECTs; magnus exposes ivar_set
+    // through RObject, not through its Exception wrapper.
+    if let Some(obj) = RObject::from_value(exc.as_value()) {
+        let set = |name: &str, v: usize| {
+            let _ = obj.ivar_set(name, v);
+        };
+        set("@byte_offset", offset.min(source.len()));
+        set("@line", loc.line);
+        set("@column", loc.column);
+        if let Some(snippet) = &loc.snippet {
+            let _ = obj.ivar_set("@snippet", snippet.as_str());
+        }
+    }
+    Error::from(exc)
+}
+
+/// A resolved source position: 1-based line, 1-based character column
+/// within that line, and a two-line caret snippet (`None` when the
+/// offending line is empty or not valid UTF-8).
+struct Location {
+    line: usize,
+    column: usize,
+    snippet: Option<String>,
+}
+
+/// UTF-8 continuation bytes are 0b10xxxxxx; every other byte starts a
+/// character, so counting non-continuation bytes counts characters.
+const UTF8_CONTINUATION_MASK: u8 = 0b1100_0000;
+const UTF8_CONTINUATION_BITS: u8 = 0b1000_0000;
+
+fn count_chars(bytes: &[u8]) -> usize {
+    bytes
+        .iter()
+        .filter(|&&b| b & UTF8_CONTINUATION_MASK != UTF8_CONTINUATION_BITS)
+        .count()
+}
+
+fn locate(source: &[u8], offset: usize) -> Location {
+    let off = offset.min(source.len());
+    let line = 1 + count_newlines(&source[..off]);
+    let line_start = source[..off]
+        .iter()
+        .rposition(|&b| b == b'\n')
+        .map_or(0, |p| p + 1);
+    let mut line_end = source[off..]
+        .iter()
+        .position(|&b| b == b'\n')
+        .map_or(source.len(), |p| off + p);
+    if line_end > line_start && source[line_end - 1] == b'\r' {
+        line_end -= 1;
+    }
+    // An offset sitting on the line terminator itself carets one past
+    // the last character of the line's content.
+    let caret = off.clamp(line_start, line_end);
+    let column = 1 + count_chars(&source[line_start..caret]);
+    let snippet = std::str::from_utf8(&source[line_start..line_end])
+        .ok()
+        .and_then(|l| build_snippet(l, caret - line_start));
+    Location {
+        line,
+        column,
+        snippet,
+    }
+}
+
+fn count_newlines(bytes: &[u8]) -> usize {
+    bytes.iter().filter(|&&b| b == b'\n').count()
+}
+
+/// Characters kept around the caret. Minified JSON is routinely one
+/// multi-kilobyte line, so the snippet shows a window, not the line.
+const SNIPPET_CHARS_BEFORE: usize = 50;
+const SNIPPET_CHARS_AFTER: usize = 30;
+const SNIPPET_ELLIPSIS: char = '…';
+
+/// Render the offending line plus a caret line underneath, windowed
+/// around `caret_byte` (a byte offset into `line`).
+fn build_snippet(line: &str, caret_byte: usize) -> Option<String> {
+    if line.is_empty() {
+        return None;
+    }
+    let mut caret_byte = caret_byte.min(line.len());
+    while !line.is_char_boundary(caret_byte) {
+        caret_byte -= 1;
+    }
+    let caret_chars = line[..caret_byte].chars().count();
+    let total_chars = caret_chars + line[caret_byte..].chars().count();
+
+    let window_first = caret_chars.saturating_sub(SNIPPET_CHARS_BEFORE);
+    let window_last = (caret_chars + SNIPPET_CHARS_AFTER).min(total_chars);
+    let mut caret_column = caret_chars - window_first;
+
+    let mut out = String::new();
+    if window_first > 0 {
+        out.push(SNIPPET_ELLIPSIS);
+        caret_column += 1;
+    }
+    for ch in line
+        .chars()
+        .skip(window_first)
+        .take(window_last - window_first)
+    {
+        // Control characters (tabs included) render as one space so
+        // the caret column stays aligned with what is printed.
+        out.push(if ch.is_control() { ' ' } else { ch });
+    }
+    if window_last < total_chars {
+        out.push(SNIPPET_ELLIPSIS);
+    }
+    out.push('\n');
+    for _ in 0..caret_column {
+        out.push(' ');
+    }
+    out.push('^');
+    Some(out)
+}

data/ext/nosj/src/files.rs

@@ -17,9 +17,10 @@ use std::io::Read;
 use magnus::value::ReprValue;
 use magnus::{Error, RArray, RString, Ruby, Value};
 
+use crate::errors::{parser_error_at, runtime_error};
 use crate::gen;
 use crate::lazy::{self, DocBytes};
-use crate::parse::{err, materialize, parse_native_opts, ParseNativeOpts};
+use crate::parse::{err, materialize, materialize_at, parse_native_opts, span_of, ParseNativeOpts};
 use crate::pointer::path_to_pointer;
 use crate::state::PULL_STATE;
 
@@ -60,16 +61,16 @@ fn errno_of(e: &std::io::Error) -> Option<i32> {
 fn io_error(ruby: &Ruby, path: &str, e: &std::io::Error) -> Error {
     use magnus::rb_sys::FromRawValue;
     let Some(errno) = errno_of(e) else {
-        return err(ruby, format!("{e} - {path}"));
+        return runtime_error(ruby, format!("{e} - {path}"));
     };
     let Ok(cpath) = std::ffi::CString::new(path) else {
-        return err(ruby, format!("{e} - {path}"));
+        return runtime_error(ruby, format!("{e} - {path}"));
     };
     // SAFETY: rb_syserr_new returns a live Errno exception instance.
     let exc = unsafe { Value::from_raw(rb_sys::rb_syserr_new(errno, cpath.as_ptr())) };
     match magnus::Exception::from_value(exc) {
         Some(exc) => exc.into(),
-        None => err(ruby, format!("{e} - {path}")),
+        None => runtime_error(ruby, format!("{e} - {path}")),
     }
 }
 
@@ -128,8 +129,26 @@ pub fn write_file_native(
     })
 }
 
+/// `NOSJ.write_lines(path, values, opts)`: generate NDJSON (one
+/// document per element, newline-terminated) and write the bytes
+/// straight from the generator's pooled buffer. Returns the byte
+/// count, like `File.write`.
+pub fn write_lines_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    path: RString,
+    values: magnus::RArray,
+    opts: Value,
+) -> Result<usize, Error> {
+    let p = path.to_string()?;
+    gen::generate_lines_bytes_into(ruby, values, opts, |ruby, bytes| {
+        fs::write(&p, bytes).map_err(|e| io_error(ruby, &p, &e))?;
+        Ok(bytes.len())
+    })
+}
+
 /// Map `path` read-only and hand a UTF-8-checked view to `f`.
-fn with_mapped_file<R>(
+pub(crate) fn with_mapped_file<R>(
     ruby: &Ruby,
     path: &str,
     f: impl FnOnce(memmap2::Mmap) -> Result<R, Error>,
@@ -178,11 +197,14 @@ fn resolve_file_pointer(
         });
         match resolved {
             Ok(None) => Ok(ruby.qnil().as_value()),
-            Ok(Some(slice)) => materialize(ruby, slice.as_bytes(), o),
+            Ok(Some(slice)) => {
+                let (start, end) = span_of(&map, slice.as_bytes());
+                materialize_at(ruby, &map, start, end, 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())),
+            Err(e) => Err(parser_error_at(ruby, &map, e.offset, e.to_string())),
         }
     })
 }

data/ext/nosj/src/gen/errors.rs

@@ -5,9 +5,10 @@
 use magnus::error::ErrorType;
 use magnus::rb_sys::AsRawValue;
 use magnus::value::ReprValue;
-use magnus::{Error, ExceptionClass, Module, RModule, Ruby};
+use magnus::{Error, Ruby};
 
 use super::ruby::rstring_bytes;
+use crate::errors::nosj_exception;
 
 pub(super) enum GenFail {
     /// Re-raise a Ruby exception captured by a protected call (user
@@ -22,14 +23,6 @@ pub(super) enum GenFail {
     Nesting(usize),
 }
 
-fn nosj_exception(ruby: &Ruby, name: &str) -> ExceptionClass {
-    let lookup = || -> Result<ExceptionClass, Error> {
-        let m: RModule = ruby.define_module("NOSJ")?;
-        m.const_get(name)
-    };
-    lookup().unwrap_or_else(|_| ruby.exception_runtime_error())
-}
-
 /// The exception's `to_s` (its message), matching what the gem embeds
 /// when it wraps a secondary exception.
 fn error_message(err: &Error) -> String {