nosj 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 938bbe04908f0865a510008040c4a1bf8f1e4b1cb80821de3757e3ac078f2e47
-  data.tar.gz: feea0d89e6f7559642127a2333d01cc3f93b1d3763e54f6ed620b596a7102d30
+  metadata.gz: 354e310be9d2d56119d2db1f9ad13052c9a6bc8fba5c8d7b7993b78abf345e1e
+  data.tar.gz: b21acc76a56a10a56c62c370ff1dfcaa8dc263a96958fcac6c4f3c213c4bb542
 SHA512:
-  metadata.gz: b1ff3aef1231141f9333030016f1ff308a81ca27a1ad8318fadf2ce42c77869756c5674716485c4b5be4ca948290f4450142c59eed76df2894bde460cd0530bc
-  data.tar.gz: 5e40f2cfb493c13b546ef3367e02efafb7eea5697181b0daad9efeed89f06db58b0db798cd5cad2f09555ee900c673753595584829ab333bdc125c45eaeca41a
+  metadata.gz: c672e8653239dc1600ce19b4b38c31ae298dbf40a79449fe12ccf05335144eed7d210a115e87a3a60e8b534b868d3c0080079072ed21a8e67b398e2e8d7e8fc4
+  data.tar.gz: 22aadd62a736d86fe310ed099d995fe6006e149103eb95d41d128adc6164e6c2f64c2de49e6652437bccefbef70379b27cc3700d45fcad7ae1e2003ac6f05f41

data/CHANGELOG.md

@@ -1,3 +1,64 @@
+## [0.5.0] - 2026-09-25
+
+**json 3.0 compatibility.** nosj now matches the behavior of the json
+gem 3.0, and stays compatible with both the json 2.x and 3.0
+interfaces: `NOSJ.parse`, `NOSJ.generate`, and the rest of nosj's own
+API follow json 3.0 semantics, while the `nosj/json` drop-in follows
+whichever json gem your application has installed, 2.x or 3.0, down to
+its calling conventions and the documents it accepts. Upgrading json
+(or not) is your choice; nosj works with either.
+
+Behavior changes in nosj's own API, for input that was accepted
+before:
+
+- Duplicate object keys raise `NOSJ::ParserError` (positioned at the
+  object repeating the key, like json 3) in `parse`, `load_file`,
+  `valid?` (returns false), `minify`/`reformat`, and everything that
+  materializes values. `allow_duplicate_key: true` restores the old
+  behavior: the last value wins (in `minify`, repeated keys pass
+  through).
+- Lone UTF-16 surrogates such as `"\udc00"` raise `NOSJ::ParserError`
+  everywhere, trailing ones included (they used to decode to raw
+  WTF-8 bytes, and `minify` re-escaped them).
+- `generate` raises `NOSJ::GeneratorError` for keys that render alike
+  (`{"a" => 1, :a => 2}`, `{1 => 1, "1" => 2}`), with json 3's exact
+  message; `allow_duplicate_key: true` emits them as before. Hashes
+  whose keys are all of one kind are never checked. The Rails encoder
+  is unchanged.
+- `stats` still describes such documents rather than refusing them.
+- Unknown options raise ArgumentError with json 3's message
+  (`unknown keyword: foo`) in every entry point, instead of being
+  ignored. json options nosj does not implement (`object_class`,
+  `array_class`, `decimal_class`, `on_load`, `create_additions`,
+  `allow_comments`, `allow_control_characters`,
+  `allow_invalid_escape`, `sort_keys`, `as_json`) raise unless falsy;
+  `on_load` and the newer ones used to be silently ignored.
+  `escape_slash` is gone, as in json 3: use `script_safe`.
+  `quirks_mode` is no longer accepted. `stats` takes only the options
+  it documents (`max_nesting`, `allow_nan`, `allow_trailing_comma`).
+
+The `nosj/json` drop-in follows the installed json gem:
+
+- With json 3.0, `JSON.parse` takes keyword options only, `JSON.dump`
+  uses json 3's defaults (nesting capped at 100), and whatever json 3
+  refuses (`quirks_mode`, `escape_slash`, `create_additions`, unknown
+  options, positional option hashes) raises exactly as json 3 raises.
+- With json 2.x, everything behaves as before, including json 2's
+  acceptance of duplicate keys, lone surrogates, and comments, and
+  its handling of keys that render alike.
+- Whenever the fast path refuses a call, the installed gem runs it
+  again and decides: exceptions are now the gem's own (message,
+  `json_path`, `invalid_object`) rather than nosj's messages re-raised
+  as JSON classes. The second pass happens on failures only, and a
+  `generate` run twice this way calls `to_json` again on the objects
+  visited before the refusal.
+- Fixed: `JSON.dump` raised NameError (`_dump_default_options`) with
+  json older than 2.11, which includes the json bundled with Ruby 3.3
+  and 3.4.
+- Fixed: `JSON.generate` (and `pretty_generate`, `dump`) with both
+  `ascii_only` and `script_safe` raised ArgumentError; that combination,
+  which nosj does not implement, now goes to the gem.
+
 ## [0.4.1] - 2026-09-25
 
 - Fixed a crash in `NOSJ.generate`: an object whose `to_json` or

data/Cargo.lock

@@ -200,7 +200,7 @@ dependencies = [
 
 [[package]]
 name = "nosj_native"
-version = "0.4.1"
+version = "0.5.0"
 dependencies = [
  "ahash",
  "magnus",

data/README.md

@@ -65,6 +65,10 @@ through nosj:
 require "nosj/json"
 ```
 
+It works with json 2.x and 3.0 alike and follows whichever your app
+has installed: its calling conventions, its defaults, and the documents
+it accepts.
+
 In a Bundler app (Rails included) that can live entirely in the
 Gemfile you can do this:
 
@@ -108,9 +112,11 @@ The `json` gem API, on the `NOSJ` module:
 
 ```ruby
 NOSJ.parse(src, symbolize_names: true)   # also: freeze, max_nesting,
-                                         # allow_nan, allow_trailing_comma
+                                         # allow_nan, allow_trailing_comma,
+                                         # allow_duplicate_key
 NOSJ.generate(obj)                       # indent, space, object_nl, ...,
-NOSJ.pretty_generate(obj)                # ascii_only, script_safe, strict
+NOSJ.pretty_generate(obj)                # ascii_only, script_safe, strict,
+                                         # allow_duplicate_key
 ```
 
 ### Lazy documents
@@ -189,10 +195,11 @@ NOSJ.reformat_file("big.json")           # straight off a memory map
 ```
 
 Output is exactly `generate(parse(json))`—canonical number spellings,
-normalized escapes, same formatting options—except duplicate keys pass
-through (a reformatter must not silently drop data) and lone-surrogate
-strings re-escape instead of raising. Acceptance options apply too:
-`minify(src, allow_trailing_comma: true)` normalizes the commas away.
+normalized escapes, same formatting options—and it accepts exactly what
+`parse` does. Acceptance options apply too:
+`minify(src, allow_trailing_comma: true)` normalizes the commas away,
+and under `allow_duplicate_key: true` repeated keys pass through (a
+reformatter must not silently drop data).
 
 ### Byte-splicing edits and JSON Patch
 
@@ -403,19 +410,28 @@ Reproduce with `rake bench` (the parity-gated comparison, after a PGO retrain—
 
 ## Switching from the json gem
 
-You mostly don't have to do anything. Some differences:
-
-- The legacy object-deserialization options (`create_additions`,
-  `object_class`, `array_class`, `decimal_class`) raise ArgumentError;
-  the `nosj/json` drop-in falls back to the original gem for them.
-- Behaviors the `json` gem itself deprecates (JS comments, raw invalid
-  UTF-8) follow the strict semantics instead.
+You mostly don't have to do anything. `NOSJ.*` follows json 3.0,
+whichever json your app runs; the `nosj/json` drop-in follows the
+installed one, 2.x or 3.0. Some differences:
+
+- json 3.0 semantics: duplicate keys, lone surrogates, JS comments,
+  and invalid UTF-8 are errors (`allow_duplicate_key: true` restores
+  last-key-wins), keys that render alike raise in `generate`, and
+  unknown options raise ArgumentError. With json 2.x installed, the
+  drop-in keeps json 2's leniency: when nosj refuses a call, the
+  installed gem runs it and has the last word.
+- The json options nosj doesn't implement (`create_additions`,
+  `object_class`, `array_class`, `decimal_class`, `on_load`,
+  `allow_comments`, `allow_control_characters`,
+  `allow_invalid_escape`, `sort_keys`, `as_json`) raise ArgumentError
+  unless falsy; the drop-in passes them to the original gem.
 - Unlike `Array#dig`, negative indices in `NOSJ.dig` return nil (JSON
   Pointer has no equivalent).
 - Parse errors raise `NOSJ::ParserError` (`NOSJ::NestingError` past
   `max_nesting`, like the gem); messages use byte offsets rather than
   the gem's phrasing, and the exception carries `#line`, `#column`,
-  and a caret `#snippet`.
+  and a caret `#snippet`. Through the drop-in, exceptions are the
+  installed gem's own (message, `json_path`, `invalid_object`).
 
 Everything else—including the gem's exact float formatting, which is
 not the shortest-round-trip form most libraries emit—matches

data/ext/nosj/Cargo.toml

@@ -5,7 +5,7 @@
 # required by lib/nosj.rb as "nosj/nosj" (Init_nosj set explicitly in
 # lib.rs). Gem name, module, and API are plain nosj.
 name = "nosj_native"
-version = "0.4.1"
+version = "0.5.0"
 edition = "2021"
 authors = ["Yaroslav Markin <yaroslav@markin.net>"]
 license = "MIT"

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

@@ -48,7 +48,14 @@ module NOSJFuzz
     rescue *PARSE_FAIL
       false
     end
-    raise "stats disagrees with parse on acceptance" unless stats_ok == (status == :ok)
+    # stats describes documents rather than refusing them: it accepts
+    # everything parse accepts, plus duplicate keys and lone surrogates
+    # (json 3 refusals parse makes on top of the grammar).
+    raise "stats refused what parse accepted" if status == :ok && !stats_ok
+    if status == :err && stats_ok &&
+        try_parse(s, {allow_duplicate_key: true})[0] != :ok && !s.include?("\\u")
+      raise "stats accepted what parse refused for a grammar reason"
+    end
 
     min_status, min = begin
       [:ok, NOSJ.reformat_native(s, nil)]
@@ -59,24 +66,17 @@ module NOSJFuzz
     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.
+      # The pipe may abort with GeneratorError (a 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
+      # float (1e999, a 300-digit integer with a small exponent) may
+      # abort the pipe, and allow_nan lifts exactly that refusal.
+      stage("reformat with allow_nan") { NOSJ.reformat_native(s, {allow_nan: true}) }
       return
     end
     raise "reformat refused what parse accepted" unless min_status == :ok
@@ -140,11 +140,9 @@ module NOSJFuzz
     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
+      # Parsed values are always generable: parse refuses lone
+      # surrogates, the only source of unencodable strings.
+      ndjson = stage("generate_lines") { NOSJ.generate_lines_native(yielded, nil) }
       back = []
       NOSJ.each_line_native(ndjson, nil) { |v| back << v }
       raise "generate_lines does not round-trip" unless back.eql?(yielded)
@@ -168,16 +166,11 @@ module NOSJFuzz
     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)
 
+    # Parsing refuses duplicate keys (raw-byte resolution would see the
+    # first occurrence, the tree the last) and lone surrogates, so an
+    # accepted tree and spec are free of both.
     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
@@ -380,21 +373,4 @@ module NOSJFuzz
     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/gen/opts.rs

@@ -5,6 +5,9 @@ use magnus::value::ReprValue;
 use magnus::{Error, RHash, RString, Ruby, Value};
 use nosj::emit::EscapeMode;
 
+use crate::opt_reader::{Opt, OptReader};
+use crate::sink::MAX_NESTING;
+
 pub(crate) struct GenConfig {
     pub(crate) indent: Vec<u8>,
     pub(crate) space: Vec<u8>,
@@ -21,195 +24,129 @@ pub(crate) struct GenConfig {
     /// null (Float#as_json parity). Set only by the Rails entry, never
     /// from user option hashes.
     pub(super) rails: bool,
+    /// json 3: keys that render the same (`"a"` and `:a`) raise unless
+    /// this is set. The Rails configs keep ActiveSupport's own handling.
+    pub(super) allow_duplicate_key: bool,
     pub(crate) mode: EscapeMode,
     /// Precomputed "any formatting string set": scanning the five
     /// vectors per call was measurable on tiny documents.
     pub(super) pretty: bool,
 }
 
+/// The json gem's defaults under an escape mode, for the plain walk or
+/// the Rails encoder's (which keeps ActiveSupport's own key handling,
+/// so it allows keys that render alike). A const fn because statics
+/// cannot struct-update a type with `Vec` fields; `Vec::new` is const
+/// and allocation-free.
+const fn defaults(rails: bool, mode: EscapeMode) -> GenConfig {
+    GenConfig {
+        indent: Vec::new(),
+        space: Vec::new(),
+        space_before: Vec::new(),
+        object_nl: Vec::new(),
+        array_nl: Vec::new(),
+        max_nesting: MAX_NESTING,
+        start_depth: 0,
+        allow_nan: false,
+        strict: false,
+        rails,
+        allow_duplicate_key: rails,
+        mode,
+        pretty: false,
+    }
+}
+
 /// The nil-options configuration, shared instead of rebuilt: stamping
 /// a fresh ~140-byte GenConfig onto the stack per call was measurable
 /// on tiny documents (the json gem likewise reuses a cached State for
-/// the default options). Safe as a static: `Vec::new` is const and
-/// allocation-free, and generation only ever borrows the config.
-pub(crate) static DEFAULT_CONFIG: GenConfig = GenConfig {
-    indent: Vec::new(),
-    space: Vec::new(),
-    space_before: Vec::new(),
-    object_nl: Vec::new(),
-    array_nl: Vec::new(),
-    max_nesting: 100,
-    start_depth: 0,
-    allow_nan: false,
-    strict: false,
-    rails: false,
-    mode: EscapeMode::Standard,
-    pretty: false,
-};
+/// the default options). Safe as a static: generation only ever
+/// borrows the config.
+pub(crate) static DEFAULT_CONFIG: GenConfig = defaults(false, EscapeMode::Standard);
 
 /// The Rails-encoder configuration for ActiveSupport's default escape
 /// flags (HTML entities and JS separators both on, the overwhelmingly
 /// common case): escaping is fused into the crate's HtmlSafe kernels,
 /// one pass, no post-scan.
-pub(super) static RAILS_HTML_SAFE_CONFIG: GenConfig = GenConfig {
-    indent: Vec::new(),
-    space: Vec::new(),
-    space_before: Vec::new(),
-    object_nl: Vec::new(),
-    array_nl: Vec::new(),
-    max_nesting: 100,
-    start_depth: 0,
-    allow_nan: false,
-    strict: false,
-    rails: true,
-    mode: EscapeMode::HtmlSafe,
-    pretty: false,
-};
+pub(super) static RAILS_HTML_SAFE_CONFIG: GenConfig = defaults(true, EscapeMode::HtmlSafe);
 
 /// Rails-encoder configuration with HTML entities on and JS separators
 /// off.
-pub(super) static RAILS_HTML_ENTITIES_CONFIG: GenConfig = GenConfig {
-    indent: Vec::new(),
-    space: Vec::new(),
-    space_before: Vec::new(),
-    object_nl: Vec::new(),
-    array_nl: Vec::new(),
-    max_nesting: 100,
-    start_depth: 0,
-    allow_nan: false,
-    strict: false,
-    rails: true,
-    mode: EscapeMode::HtmlEntities,
-    pretty: false,
-};
+pub(super) static RAILS_HTML_ENTITIES_CONFIG: GenConfig = defaults(true, EscapeMode::HtmlEntities);
 
 /// Rails-encoder configuration with JS separators on and HTML entities
 /// off.
-pub(super) static RAILS_JS_SEPARATORS_CONFIG: GenConfig = GenConfig {
-    indent: Vec::new(),
-    space: Vec::new(),
-    space_before: Vec::new(),
-    object_nl: Vec::new(),
-    array_nl: Vec::new(),
-    max_nesting: 100,
-    start_depth: 0,
-    allow_nan: false,
-    strict: false,
-    rails: true,
-    mode: EscapeMode::JsSeparators,
-    pretty: false,
-};
+pub(super) static RAILS_JS_SEPARATORS_CONFIG: GenConfig = defaults(true, EscapeMode::JsSeparators);
 
 /// The Rails-encoder configuration with every escape flag off
 /// (encode(escape: false)). Mirrors JSONGemEncoder#stringify, which
 /// generates with the json gem's defaults.
-pub(super) static RAILS_CONFIG: GenConfig = GenConfig {
-    indent: Vec::new(),
-    space: Vec::new(),
-    space_before: Vec::new(),
-    object_nl: Vec::new(),
-    array_nl: Vec::new(),
-    max_nesting: 100,
-    start_depth: 0,
-    allow_nan: false,
-    strict: false,
-    rails: true,
-    mode: EscapeMode::Standard,
-    pretty: false,
-};
+pub(super) static RAILS_CONFIG: GenConfig = defaults(true, EscapeMode::Standard);
 
 impl Default for GenConfig {
     fn default() -> Self {
-        GenConfig {
-            indent: Vec::new(),
-            space: Vec::new(),
-            space_before: Vec::new(),
-            object_nl: Vec::new(),
-            array_nl: Vec::new(),
-            max_nesting: 100,
-            start_depth: 0,
-            allow_nan: false,
-            strict: false,
-            rails: false,
-            mode: EscapeMode::Standard,
-            pretty: false,
-        }
+        defaults(false, EscapeMode::Standard)
     }
 }
 
-fn opt_bytes(ruby: &Ruby, opts: RHash, name: &str) -> Result<Option<Vec<u8>>, Error> {
-    let v: Value = opts
-        .get(ruby.to_symbol(name))
-        .unwrap_or_else(|| ruby.qnil().as_value());
-    if v.is_nil() {
-        return Ok(None);
-    }
+/// A formatting string option's bytes; empty when absent or nil.
+fn opt_bytes(r: &mut OptReader, opt: Opt) -> Result<Vec<u8>, Error> {
+    let Some(v) = r.get(opt).filter(|v| !v.is_nil()) else {
+        return Ok(Vec::new());
+    };
     let s = RString::from_value(v).ok_or_else(|| {
         Error::new(
-            ruby.exception_type_error(),
-            format!("{name} must be a String"),
+            r.ruby().exception_type_error(),
+            format!("{} must be a String", opt.name()),
         )
     })?;
-    Ok(Some(unsafe { s.as_slice() }.to_vec()))
+    Ok(unsafe { s.as_slice() }.to_vec())
 }
 
-fn opt_bool(ruby: &Ruby, opts: RHash, name: &str) -> Option<bool> {
-    let v: Value = opts.get(ruby.to_symbol(name))?;
-    if v.is_nil() {
-        None
-    } else {
-        Some(v.to_bool())
-    }
-}
-
-/// Decode a non-nil options hash (nil takes [`DEFAULT_CONFIG`] at the
-/// call site without constructing anything).
+/// Decode a generate options hash (nil takes [`DEFAULT_CONFIG`] at the
+/// call site without constructing anything); keys it does not read
+/// raise ArgumentError, like json 3.
 pub(crate) fn parse_gen_opts(ruby: &Ruby, opts: Value) -> Result<(GenConfig, usize), Error> {
-    let mut cfg = GenConfig::default();
-    let mut cap_hint = 0usize;
     if opts.is_nil() {
-        return Ok((cfg, cap_hint));
+        return Ok((GenConfig::default(), 0));
     }
     let opts = RHash::from_value(opts)
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "options must be a Hash or nil"))?;
+    let mut reader = OptReader::new(ruby, opts);
+    let decoded = read_gen_opts(&mut reader)?;
+    reader.finish()?;
+    Ok(decoded)
+}
 
-    if let Some(v) = opt_bytes(ruby, opts, "indent")? {
-        cfg.indent = v;
-    }
-    if let Some(v) = opt_bytes(ruby, opts, "space")? {
-        cfg.space = v;
-    }
-    if let Some(v) = opt_bytes(ruby, opts, "space_before")? {
-        cfg.space_before = v;
-    }
-    if let Some(v) = opt_bytes(ruby, opts, "object_nl")? {
-        cfg.object_nl = v;
-    }
-    if let Some(v) = opt_bytes(ruby, opts, "array_nl")? {
-        cfg.array_nl = v;
-    }
-    if let Some(v) = opt_bool(ruby, opts, "allow_nan") {
-        cfg.allow_nan = v;
-    }
-    if let Some(v) = opt_bool(ruby, opts, "strict") {
-        cfg.strict = v;
-    }
-    let ascii = opt_bool(ruby, opts, "ascii_only").unwrap_or(false);
-    let script = opt_bool(ruby, opts, "script_safe").unwrap_or(false)
-        || opt_bool(ruby, opts, "escape_slash").unwrap_or(false);
+/// Read the json 3 generate options and the buffer size hint. sort_keys
+/// and as_json, which NOSJ does not implement, raise unless falsy.
+pub(crate) fn read_gen_opts(r: &mut OptReader) -> Result<(GenConfig, usize), Error> {
+    let mut cfg = GenConfig {
+        indent: opt_bytes(r, Opt::Indent)?,
+        space: opt_bytes(r, Opt::Space)?,
+        space_before: opt_bytes(r, Opt::SpaceBefore)?,
+        object_nl: opt_bytes(r, Opt::ObjectNl)?,
+        array_nl: opt_bytes(r, Opt::ArrayNl)?,
+        allow_nan: r.truthy(Opt::AllowNan),
+        strict: r.truthy(Opt::Strict),
+        allow_duplicate_key: r.truthy(Opt::AllowDuplicateKey),
+        ..GenConfig::default()
+    };
+    let mut cap_hint = 0usize;
+    r.tolerate(&[Opt::SortKeys, Opt::AsJson]);
+    let ascii = r.truthy(Opt::AsciiOnly);
+    let script = r.truthy(Opt::ScriptSafe);
     if ascii {
         cfg.mode = EscapeMode::AsciiOnly;
         if script {
             return Err(Error::new(
-                ruby.exception_arg_error(),
+                r.ruby().exception_arg_error(),
                 "NOSJ.generate: ascii_only and script_safe cannot be combined",
             ));
         }
     } else if script {
         cfg.mode = EscapeMode::ScriptSafe;
     }
-    if let Some(v) = opts.get(ruby.to_symbol("max_nesting")) {
-        let v: Value = v;
+    if let Some(v) = r.get(Opt::MaxNesting) {
         // nil/false → unlimited; true → keep the default 100; Integer → limit.
         if !v.to_bool() {
             cfg.max_nesting = 0;
@@ -217,14 +154,12 @@ pub(crate) fn parse_gen_opts(ruby: &Ruby, opts: Value) -> Result<(GenConfig, usi
             cfg.max_nesting = if n <= 0 { 0 } else { n as usize };
         }
     }
-    if let Some(v) = opts.get(ruby.to_symbol("depth")) {
-        let v: Value = v;
+    if let Some(v) = r.get(Opt::Depth) {
         if let Ok(n) = <i64 as magnus::TryConvert>::try_convert(v) {
             cfg.start_depth = if n <= 0 { 0 } else { n as usize };
         }
     }
-    if let Some(v) = opts.get(ruby.to_symbol("buffer_initial_length")) {
-        let v: Value = v;
+    if let Some(v) = r.get(Opt::BufferInitialLength) {
         if let Ok(n) = <i64 as magnus::TryConvert>::try_convert(v) {
             if n > 0 {
                 cap_hint = n as usize;

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

@@ -18,6 +18,11 @@ pub(super) fn protected_to_s(v: VALUE) -> Result<VALUE, Error> {
     magnus::rb_sys::protect(|| unsafe { rb_sys::rb_obj_as_string(v) })
 }
 
+/// `v.inspect`, protected (user code for any element's `inspect`).
+pub(super) fn protected_inspect(v: VALUE) -> Result<VALUE, Error> {
+    magnus::rb_sys::protect(|| unsafe { rb_sys::rb_inspect(v) })
+}
+
 /// `v.to_json`, protected.
 pub(super) fn protected_to_json(v: VALUE) -> Result<VALUE, Error> {
     magnus::rb_sys::protect(|| unsafe { rb_sys::rb_funcall(v, to_json_id(), 0) })