nosj 0.4.0 → 0.5.0

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,11 +18,31 @@ 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) })
 }
 
+/// `v.to_json` if `v.respond_to?(:to_json)`, else `None`, under ONE
+/// protect: `rb_respond_to` dispatches to a user-defined `respond_to?` /
+/// `respond_to_missing?`, which may raise just like `to_json` itself.
+pub(super) fn protected_to_json_if_responds(v: VALUE) -> Result<Option<VALUE>, Error> {
+    const QUNDEF: VALUE = ruby_special_consts::RUBY_Qundef as VALUE;
+    let json = magnus::rb_sys::protect(|| unsafe {
+        if rb_sys::rb_respond_to(v, to_json_id()) != 0 {
+            rb_sys::rb_funcall(v, to_json_id(), 0)
+        } else {
+            QUNDEF
+        }
+    })?;
+    Ok((json != QUNDEF).then_some(json))
+}
+
 /// `v.as_json`, protected. Argument-less on purpose: ActiveSupport's
 /// JSONGemEncoder#jsonify recursion also calls as_json without
 /// options (only the top-level value receives them).
@@ -53,33 +73,37 @@ pub(crate) fn warm_up() {
 /// first generate is still found; a fragment instance existing implies
 /// its class does. The cached VALUE is a constant of the JSON module,
 /// so it can never be collected.
-pub(super) fn is_json_fragment(v: VALUE) -> bool {
+pub(super) fn is_json_fragment(v: VALUE) -> Result<bool, Error> {
     use std::sync::atomic::{AtomicUsize, Ordering};
     static FRAGMENT: AtomicUsize = AtomicUsize::new(0);
-    let mut cls = FRAGMENT.load(Ordering::Relaxed);
+    let mut cls = FRAGMENT.load(Ordering::Relaxed) as VALUE;
     if cls == 0 {
-        cls = resolve_json_fragment();
+        cls = resolve_json_fragment()?;
         if cls == 0 {
-            return false;
+            return Ok(false);
         }
-        FRAGMENT.store(cls, Ordering::Relaxed);
+        FRAGMENT.store(cls as usize, Ordering::Relaxed);
     }
-    unsafe { rb_sys::rb_obj_is_kind_of(v, cls as VALUE) != QFALSE }
+    Ok(unsafe { rb_sys::rb_obj_is_kind_of(v, cls) != QFALSE })
 }
 
-fn resolve_json_fragment() -> usize {
+/// `JSON::Fragment`, or 0 while undefined. Only the `rb_const_get`s are
+/// protected: fetching a constant can run its pending autoload (user
+/// code, whose raise propagates as any constant reference's would),
+/// while `rb_const_defined` never loads anything.
+fn resolve_json_fragment() -> Result<VALUE, Error> {
     unsafe {
         let object = rb_sys::rb_cObject;
         let json_id = rb_sys::rb_intern(c"JSON".as_ptr());
         if rb_sys::rb_const_defined(object, json_id) == 0 {
-            return 0;
+            return Ok(0);
         }
-        let json = rb_sys::rb_const_get(object, json_id);
+        let json = magnus::rb_sys::protect(|| rb_sys::rb_const_get(object, json_id))?;
         let fragment_id = rb_sys::rb_intern(c"Fragment".as_ptr());
         if rb_sys::rb_const_defined(json, fragment_id) == 0 {
-            return 0;
+            return Ok(0);
         }
-        rb_sys::rb_const_get(json, fragment_id) as usize
+        magnus::rb_sys::protect(|| rb_sys::rb_const_get(json, fragment_id))
     }
 }
 
@@ -95,7 +119,7 @@ pub(super) fn protected_encode_utf8(v: VALUE) -> Result<VALUE, Error> {
 }
 
 /// Interned `to_json` method ID, resolved once per process.
-pub(super) fn to_json_id() -> rb_sys::ID {
+fn to_json_id() -> rb_sys::ID {
     static TO_JSON: OnceLock<usize> = OnceLock::new();
     *TO_JSON.get_or_init(|| unsafe { rb_sys::rb_intern(c"to_json".as_ptr()) } as usize)
         as rb_sys::ID
@@ -109,12 +133,16 @@ pub(super) fn utf8_encindexes() -> (c_int, c_int) {
 // Coderange and encoding index live in RBasic flags (public ABI); reading
 // them inline instead of calling rb_enc_str_coderange / rb_enc_get_index is
 // how the gem avoids two C calls per string (RB_ENC_CODERANGE,
-// RB_ENCODING_GET_INLINED).
-const CR_MASK: u64 = 3 << 20;
-pub(super) const CR_7BIT: u64 = 1 << 20;
-pub(super) const CR_VALID: u64 = 2 << 20;
-const ENC_SHIFT: u64 = 22;
-const ENC_MASK: u64 = 127 << 22;
+// RB_ENCODING_GET_INLINED). The bit layout comes from rb-sys's bindings,
+// generated from the headers of the Ruby being built against, so it
+// follows any layout change instead of silently misreading flags.
+const CR_MASK: u64 = rb_sys::ruby_coderange_type::RUBY_ENC_CODERANGE_MASK as u64;
+pub(super) const CR_7BIT: u64 = rb_sys::ruby_coderange_type::RUBY_ENC_CODERANGE_7BIT as u64;
+pub(super) const CR_VALID: u64 = rb_sys::ruby_coderange_type::RUBY_ENC_CODERANGE_VALID as u64;
+const ENC_SHIFT: u64 = rb_sys::ruby_encoding_consts::RUBY_ENCODING_SHIFT as u64;
+const ENC_MASK: u64 = rb_sys::ruby_encoding_consts::RUBY_ENCODING_MASK as u64;
+/// Inline encoding-index sentinel: the real index is stored out of line.
+const ENC_INLINE_MAX: c_int = rb_sys::ruby_encoding_consts::RUBY_ENCODING_INLINE_MAX as c_int;
 
 #[inline(always)]
 pub(super) fn str_coderange(s: VALUE) -> u64 {
@@ -131,18 +159,18 @@ pub(super) fn str_coderange(s: VALUE) -> u64 {
 pub(super) fn str_enc_index(s: VALUE) -> c_int {
     let flags = unsafe { (*(s as *const rb_sys::RBasic)).flags };
     let idx = ((flags & ENC_MASK) >> ENC_SHIFT) as c_int;
-    if idx == 127 {
-        // RUBY_ENCODING_INLINE_MAX sentinel: index stored out of line.
+    if idx == ENC_INLINE_MAX {
         unsafe { rb_sys::rb_enc_get_index(s) }
     } else {
         idx
     }
 }
 
+/// `RB_SPECIAL_CONST_P` (immediates plus Qnil/Qfalse), through rb-sys's
+/// inline versioned stable API rather than a hand-copied bit test.
 #[inline(always)]
 pub(super) fn is_special_const(v: VALUE) -> bool {
-    // RB_SPECIAL_CONST_P: immediates plus Qnil/Qfalse.
-    (v & (ruby_special_consts::RUBY_IMMEDIATE_MASK as VALUE)) != 0 || v == QNIL || v == QFALSE
+    rb_sys::macros::SPECIAL_CONST_P(v)
 }
 
 /// Borrow a Ruby String's bytes.