nosj 0.4.1 → 0.5.0

data/ext/nosj/src/sink.rs

@@ -1,7 +1,8 @@
 //! 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.
+//! event; `DupKeys` gives hash-less sinks duplicate-key detection. Raw
+//! VALUE construction helpers live here too.
 
 use ahash::AHashMap;
 
@@ -17,17 +18,20 @@ 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`].
+/// [`crate::parse::drive_error`]. Sinks see no offsets, so the two
+/// document refusals get their position from a cold-path re-walk
+/// (`crate::locate`).
 pub(crate) enum SinkAbort {
     Overflow,
     BadBigint,
     TooDeep,
-    /// The reformat pipe met a WTF-8 (lone-surrogate) object KEY,
-    /// which the Writer has no pre-serialized escape hatch for; gem
-    /// parity is the GeneratorError `generate` raises on the
-    /// equivalent broken-coderange string. (String VALUES re-escape
-    /// as \uXXXX instead.)
-    BrokenUtf8Output,
+    /// An object repeats a key and `allow_duplicate_key` is off (json
+    /// 3 semantics). From `DupKeys` it may be a fingerprint collision,
+    /// which the exact cold-path check rules out.
+    DuplicateKey,
+    /// A string or key decodes to a lone UTF-16 surrogate (json 3
+    /// rejects trailing ones too, not only leading ones).
+    LoneSurrogate,
     /// The reformat pipe met a non-finite float without `allow_nan`.
     /// Parsing accepts huge-exponent literals like 1e999 as Infinity
     /// even in strict mode (gem parity), but generation refuses them;
@@ -35,6 +39,145 @@ pub(crate) enum SinkAbort {
     NonFiniteFloat(&'static str),
 }
 
+/// Duplicate-key detection for sinks that build no Hash (validation and
+/// the reformat pipe): each key is remembered as a 64-bit fingerprint,
+/// `mark()` at a container's start is the fingerprint count, and an
+/// object's close checks only its own keys. Integers, because comparing
+/// them is what keeps this cheap: comparing the key bytes themselves
+/// measured up to 93% slower (twitter's 40-key objects). A fingerprint
+/// collision reads as a duplicate, so callers confirm a hit exactly on
+/// the cold path; a collision can only cost time.
+///
+/// Measured split (twitter `valid?`): hashing and pushing each key is
+/// ~0-2%; the close-time check is the cost, hence [`SeenTable`].
+pub(crate) struct DupKeys<'a> {
+    scratch: &'a mut DupScratch,
+    enabled: bool,
+}
+
+/// [`DupKeys`]' pooled buffers (per thread, in `PullState`): the key
+/// fingerprints of every open object, and the close-time set.
+#[derive(Default)]
+pub(crate) struct DupScratch {
+    fingerprints: Vec<u64>,
+    table: SeenTable,
+}
+
+/// Fixed seeds: fingerprints only need to spread keys, and a collision
+/// merely sends the document to the exact cold-path check. (A leaner
+/// hand-rolled hash measured no faster: hashing is not the cost.)
+const FINGERPRINT: ahash::RandomState = ahash::RandomState::with_seeds(
+    0x243f_6a88_85a3_08d3,
+    0x1319_8a2e_0370_7344,
+    0xa409_3822_299f_31d0,
+    0x082e_fa98_ec4e_6c89,
+);
+
+/// Objects up to this many keys compare pairwise (a few compares beat
+/// any table traffic).
+const PAIRWISE_MAX: usize = 8;
+/// Table slots; a power of two, so a fingerprint's low bits index it.
+const TABLE_SLOTS: usize = 256;
+/// Objects up to this many keys use the table, which then stays at
+/// least half empty; larger ones sort.
+const TABLE_MAX_KEYS: usize = TABLE_SLOTS / 2;
+
+/// Open-addressing set for one object's close: fingerprints are already
+/// uniformly mixed, so their low bits index it directly, and one probe
+/// per key usually decides. Each close claims a fresh epoch, and a slot
+/// is empty unless it carries the current one, so nothing is cleared
+/// between objects.
+struct SeenTable {
+    slots: Box<[(u64, u32)]>,
+    epoch: u32,
+}
+
+impl Default for SeenTable {
+    fn default() -> Self {
+        SeenTable {
+            slots: vec![(0, 0); TABLE_SLOTS].into_boxed_slice(),
+            epoch: 0,
+        }
+    }
+}
+
+impl SeenTable {
+    /// Whether `keys` repeats a fingerprint. Callers keep
+    /// `keys.len() <= TABLE_MAX_KEYS`, so a free slot always exists.
+    #[inline(always)]
+    fn any_repeat(&mut self, keys: &[u64]) -> bool {
+        const MASK: usize = TABLE_SLOTS - 1;
+        self.epoch = self.epoch.wrapping_add(1);
+        if self.epoch == 0 {
+            // Epoch 0 marks an empty slot; after a full wrap, really clear.
+            self.slots.fill((0, 0));
+            self.epoch = 1;
+        }
+        let epoch = self.epoch;
+        for &fp in keys {
+            let mut at = fp as usize & MASK;
+            loop {
+                let slot = &mut self.slots[at];
+                if slot.1 != epoch {
+                    *slot = (fp, epoch);
+                    break;
+                }
+                if slot.0 == fp {
+                    return true;
+                }
+                at = (at + 1) & MASK;
+            }
+        }
+        false
+    }
+}
+
+impl<'a> DupKeys<'a> {
+    pub(crate) fn new(scratch: &'a mut DupScratch, enabled: bool) -> Self {
+        scratch.fingerprints.clear();
+        DupKeys { scratch, enabled }
+    }
+
+    #[inline(always)]
+    pub(crate) fn mark(&self) -> usize {
+        self.scratch.fingerprints.len()
+    }
+
+    #[inline(always)]
+    pub(crate) fn key(&mut self, key: &[u8]) {
+        if self.enabled {
+            self.scratch.fingerprints.push(FINGERPRINT.hash_one(key));
+        }
+    }
+
+    /// Close the object whose keys start at `mark`.
+    #[inline(always)]
+    pub(crate) fn close(&mut self, mark: usize) -> Result<(), SinkAbort> {
+        if !self.enabled {
+            return Ok(());
+        }
+        let DupScratch {
+            fingerprints,
+            table,
+        } = &mut *self.scratch;
+        let keys = &mut fingerprints[mark..];
+        let repeated = match keys.len() {
+            n if n <= PAIRWISE_MAX => (1..n).any(|i| keys[..i].contains(&keys[i])),
+            n if n <= TABLE_MAX_KEYS => table.any_repeat(keys),
+            _ => {
+                keys.sort_unstable();
+                keys.windows(2).any(|w| w[0] == w[1])
+            }
+        };
+        fingerprints.truncate(mark);
+        if repeated {
+            Err(SinkAbort::DuplicateKey)
+        } else {
+            Ok(())
+        }
+    }
+}
+
 /// Integer VALUE for `i` via rb-sys's inline `LONG2NUM` (the header
 /// macro: a Fixnum tagged inline when it fits, else a Bignum), which
 /// saves the FFI call per integer that `rb_ll2inum` costs. The fixable
@@ -143,6 +286,7 @@ pub(crate) struct RubyValueSink<'a> {
     pub(crate) symbolize: bool,
     pub(crate) freeze: bool,
     pub(crate) max_nesting: usize,
+    pub(crate) allow_duplicate_key: bool,
 }
 
 // Tried and rejected (2026-07-10): a jiter-style cache of repeated VALUE
@@ -225,35 +369,14 @@ impl nosj::Sink for RubyValueSink<'_> {
         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)
+    /// Lone-surrogate content (the crate hands it over as WTF-8): json 3
+    /// rejects it, trailing surrogates included.
+    fn str_bytes(&mut self, _: &[u8]) -> Result<(), SinkAbort> {
+        Err(SinkAbort::LoneSurrogate)
     }
 
-    #[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)
+    fn key_bytes(&mut self, _: &[u8]) -> Result<(), SinkAbort> {
+        Err(SinkAbort::LoneSurrogate)
     }
 
     #[inline(always)]
@@ -311,19 +434,28 @@ impl nosj::Sink for RubyValueSink<'_> {
             }
         }
         self.stack.truncate(mark);
+        // A repeated key collapses into one entry: the hash comes out
+        // smaller than the pair count (one size read per object).
+        if !self.allow_duplicate_key
+            && (unsafe { rb_sys::macros::RHASH_SIZE(hash_raw) } as usize) < pairs
+        {
+            return Err(SinkAbort::DuplicateKey);
+        }
         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 {
+/// tracking and duplicate-key fingerprints, so `NOSJ.valid?` runs the
+/// full parser (tokenizers, string decode, number validation) without
+/// allocating a single VALUE.
+pub(crate) struct NullSink<'a> {
     pub(crate) depth: usize,
     pub(crate) max_nesting: usize,
+    pub(crate) dup_keys: DupKeys<'a>,
 }
 
-impl nosj::Sink for NullSink {
+impl nosj::Sink for NullSink<'_> {
     type Error = SinkAbort;
 
     fn null(&mut self) -> Result<(), SinkAbort> {
@@ -344,14 +476,18 @@ impl nosj::Sink for NullSink {
     fn str(&mut self, _: &str) -> Result<(), SinkAbort> {
         Ok(())
     }
-    fn key(&mut self, _: &str) -> Result<(), SinkAbort> {
+    fn key(&mut self, key: &str) -> Result<(), SinkAbort> {
+        self.dup_keys.key(key.as_bytes());
         Ok(())
     }
     fn str_bytes(&mut self, _: &[u8]) -> Result<(), SinkAbort> {
-        Ok(())
+        Err(SinkAbort::LoneSurrogate)
+    }
+    fn key_bytes(&mut self, _: &[u8]) -> Result<(), SinkAbort> {
+        Err(SinkAbort::LoneSurrogate)
     }
     fn mark(&self) -> usize {
-        0
+        self.dup_keys.mark()
     }
     fn begin_array(&mut self) -> Result<(), SinkAbort> {
         self.depth += 1;
@@ -371,8 +507,8 @@ impl nosj::Sink for NullSink {
         self.depth -= 1;
         Ok(())
     }
-    fn end_object(&mut self, _: usize, _: usize) -> Result<(), SinkAbort> {
+    fn end_object(&mut self, mark: usize, _: usize) -> Result<(), SinkAbort> {
         self.depth -= 1;
-        Ok(())
+        self.dup_keys.close(mark)
     }
 }

data/ext/nosj/src/state.rs

@@ -13,6 +13,8 @@ use nosj::Buffers;
 use std::cell::Cell;
 use std::thread::LocalKey;
 
+use crate::sink::DupScratch;
+
 /// Run `f` on a pooled thread-local value, taken OUT of its cell for the
 /// call and stored back afterwards. Pooled state is never borrowed
 /// across a call that can reach Ruby: any allocation can raise
@@ -45,6 +47,8 @@ pub(crate) struct PullState {
     /// 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>,
+    /// Duplicate-key detection buffers for hash-less sinks.
+    pub(crate) dup: DupScratch,
 }
 
 impl PullState {
@@ -56,6 +60,7 @@ impl PullState {
             sym_keys: AHashMap::new(),
             vstack: None,
             key_shadow: None,
+            dup: DupScratch::default(),
         })
     }
 }

data/ext/nosj/src/stats.rs

@@ -8,9 +8,9 @@ use ahash::AHashMap;
 use magnus::value::ReprValue;
 use magnus::{Error, RHash, RString, Ruby, Value};
 
-use crate::errors::{nesting_error, parser_error, parser_error_at};
 use crate::files::with_mapped_file;
-use crate::parse::{parse_native_opts, utf8_input};
+use crate::opt_reader::{Opt, OptReader};
+use crate::parse::{drive_error, max_nesting_of, options_hash, utf8_input, ParseNativeOpts};
 use crate::sink::SinkAbort;
 use crate::state::with_pull_state;
 
@@ -239,40 +239,41 @@ fn stats_to_hash(ruby: &Ruby, s: &StatsSink, byte_size: usize) -> Result<Value,
     Ok(out.as_value())
 }
 
-/// Run the counting pass over already-UTF-8-vouched bytes and build
-/// the result. `max_nesting` here defaults to UNLIMITED (a deep blob
-/// is exactly what a diagnostic should describe, not refuse), unless
-/// the caller passes the option explicitly.
-fn stats_over(ruby: &Ruby, input: &[u8], opts: Value) -> Result<Value, Error> {
-    let o = parse_native_opts(ruby, opts)?;
-    let nesting_given =
-        RHash::from_value(opts).is_some_and(|h| h.get(ruby.to_symbol("max_nesting")).is_some());
+/// Stats' options: `max_nesting`, which here defaults to UNLIMITED (a
+/// deep blob is exactly what a diagnostic should describe, not refuse),
+/// and the grammar extensions. Decoded before the source is borrowed:
+/// a hash lookup can run a key's own `hash`/`eql?`.
+fn stats_opts(ruby: &Ruby, opts: Value) -> Result<ParseNativeOpts, Error> {
+    let mut o = ParseNativeOpts {
+        max_nesting: usize::MAX,
+        ..ParseNativeOpts::default()
+    };
+    let Some(h) = options_hash(ruby, opts)? else {
+        return Ok(o);
+    };
+    let mut r = OptReader::new(ruby, h);
+    if let Some(v) = r.get(Opt::MaxNesting) {
+        o.max_nesting = max_nesting_of(v);
+    }
+    o.popts.allow_nan = r.truthy(Opt::AllowNan);
+    o.popts.allow_trailing_comma = r.truthy(Opt::AllowTrailingComma);
+    r.finish()?;
+    Ok(o)
+}
 
+/// Run the counting pass over already-UTF-8-vouched bytes and build
+/// the result.
+fn stats_over(ruby: &Ruby, input: &[u8], o: &ParseNativeOpts) -> Result<Value, Error> {
     let mut sink = StatsSink {
-        max_nesting: if nesting_given {
-            o.max_nesting
-        } else {
-            usize::MAX
-        },
+        max_nesting: o.max_nesting,
         ..StatsSink::default()
     };
     let result = with_pull_state(|state| {
         // Safety: callers verified UTF-8 (coderange or a full scan).
         unsafe { nosj::parse_utf8_unchecked_with(input, &mut state.bufs, &mut sink, o.popts) }
     });
-    match result {
-        Ok(()) => stats_to_hash(ruby, &sink, input.len()),
-        Err(nosj::DriveError::Sink(SinkAbort::TooDeep)) => Err(nesting_error(
-            ruby,
-            format!("nesting of {} is too deep", o.max_nesting.saturating_add(1)),
-        )),
-        // The other aborts cannot happen (this sink never raises them),
-        // but the match must be total.
-        Err(nosj::DriveError::Sink(_)) => Err(parser_error(ruby, "stats pass aborted".into())),
-        Err(nosj::DriveError::Parse(e)) => {
-            Err(parser_error_at(ruby, input, e.offset, e.to_string()))
-        }
-    }
+    result.map_err(|failure| drive_error(ruby, failure, o, input, (0, input.len())))?;
+    stats_to_hash(ruby, &sink, input.len())
 }
 
 /// `NOSJ.stats(source, opts)`: document statistics from one null-sink
@@ -283,8 +284,9 @@ pub fn stats_native(
     data: RString,
     opts: Value,
 ) -> Result<Value, Error> {
+    let o = stats_opts(ruby, opts)?;
     let input = utf8_input(ruby, &data)?;
-    stats_over(ruby, input, opts)
+    stats_over(ruby, input, &o)
 }
 
 /// `NOSJ.stats_file(path, opts)`: `NOSJ.stats` against a memory-mapped
@@ -295,6 +297,7 @@ pub fn stats_file_native(
     path: RString,
     opts: Value,
 ) -> Result<Value, Error> {
+    let o = stats_opts(ruby, opts)?;
     let p = path.to_string()?;
-    with_mapped_file(ruby, &p, |map| stats_over(ruby, &map, opts))
+    with_mapped_file(ruby, &p, |map| stats_over(ruby, &map, &o))
 }

data/lib/nosj/json.rb

@@ -12,12 +12,18 @@
 # 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).
+# (json 2's JSON.load passes create_additions, so it 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).
+# The drop-in follows whichever json is installed, 2.x or 3.x: its
+# calling conventions (json 3's keyword-only parse, its dump defaults)
+# and its semantics. NOSJ implements json 3's (duplicate keys and lone
+# surrogates are errors), so whenever the fast path refuses a call, the
+# original gem runs it again and has the last word: json 2 accepts what
+# it always accepted, and every exception is the gem's own, message,
+# json_path and invalid_object included. That second pass happens on
+# failures only; a generate run twice this way calls to_json on the
+# objects visited before the refusal twice.
 #
 # Not rerouted: obj.to_json (core extensions drive the gem's generator
 # directly), and objects with a custom to_json inside a rerouted
@@ -30,15 +36,26 @@ module NOSJ
   # Implementation detail of `require "nosj/json"`.
   # @private
   module JSONDropIn
-    # quirks_mode rides the fast path because NOSJ.parse is always
-    # quirks-mode (top-level scalars parse) and ignores the key; Rails
-    # 7.x passes it from ActiveSupport::JSON.decode.
+    # json 3 made parse's options keyword-only, fixed dump's defaults and
+    # raises for options json 2 ignored or aliased.
+    JSON3 = ::JSON::VERSION.to_i >= 3
+
     PARSE_OPTS = %i[symbolize_names freeze max_nesting allow_nan
-      allow_trailing_comma quirks_mode].freeze
+      allow_trailing_comma allow_duplicate_key].freeze
+    # json 2 ignores quirks_mode, which Rails 7.x passes from
+    # ActiveSupport::JSON.decode, so its fast path takes the key and
+    # drops it (NOSJ.parse always parses top-level scalars, and refuses
+    # unknown keys). json 3 raises for it, so there it reaches the gem
+    # like any other unknown option.
+    QUIRKS_MODE = :quirks_mode
+    JSON2_PARSE_OPTS = (PARSE_OPTS + [QUIRKS_MODE]).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
+      max_nesting allow_nan ascii_only script_safe strict depth
+      buffer_initial_length allow_duplicate_key].freeze
+    JSON3_DUMP_DEFAULTS = {allow_nan: true}.freeze
+    # json 2.10 and older accept only strict: in dump's options hash,
+    # through this private helper; later versions merge any option.
+    DUMP_MERGES_OPTIONS = !::JSON.respond_to?(:merge_dump_options, true)
 
     module_function
 
@@ -52,6 +69,13 @@ module NOSJ
       true
     end
 
+    # Generate options the fast path handles: supported keys, minus the
+    # one combination NOSJ refuses (ascii_only with script_safe, which
+    # json supports).
+    def generate_supported?(opts)
+      supported?(opts, GENERATE_OPTS) && !(opts && opts[:ascii_only] && opts[:script_safe])
+    end
+
     def parse(source, opts)
       # NOSJ.parse is deliberately strict about encodings (json-3.0
       # semantics), but the drop-in must match the installed gem, which
@@ -61,30 +85,60 @@ module NOSJ
       # (copy-on-write bytes), and the validity scan is memoized
       # coderange the parse would compute anyway. Anything else
       # non-UTF-8 (UTF-16, ...) belongs to gem json, which transcodes.
+      input = source
       if source.is_a?(String)
         case source.encoding
         when Encoding::UTF_8, Encoding::US_ASCII
         # the fast path as-is
         when Encoding::BINARY
           utf8 = source.dup.force_encoding(Encoding::UTF_8)
-          source = utf8 if utf8.valid_encoding?
+          input = utf8 if utf8.valid_encoding?
         else
-          return ::JSON.nosj_original_parse(source, **(opts || {}))
+          return original_parse(source, opts)
         end
       end
-      NOSJ.parse(source, opts)
-    rescue NOSJ::NestingError => e
-      raise ::JSON::NestingError, e.message
-    rescue NOSJ::ParserError => e
-      raise ::JSON::ParserError, e.message
+      NOSJ.parse(input, opts)
+    rescue NOSJ::ParserError, NOSJ::NestingError
+      original_parse(source, opts)
+    end
+
+    # json 2's options without quirks_mode (see QUIRKS_MODE), allocating
+    # nothing for Rails' lone `quirks_mode: true`.
+    def without_quirks_mode(opts)
+      return opts unless opts&.key?(QUIRKS_MODE)
+      if opts.size == 1
+        nil
+      else
+        opts.except(QUIRKS_MODE)
+      end
+    end
+
+    # The installed gem's parse. json 3 takes keywords only; json 2's
+    # positional options hash receives them just the same.
+    def original_parse(source, opts)
+      ::JSON.nosj_original_parse(source, **(opts || {}))
     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
+    rescue NOSJ::GeneratorError, NOSJ::NestingError
+      if pretty
+        ::JSON.nosj_original_pretty_generate(obj, opts)
+      else
+        ::JSON.nosj_original_generate(obj, opts)
+      end
+    end
+
+    # The options JSON.dump generates with before the caller's own: fixed
+    # in json 3; json 2 reads its user-settable dump_default_options,
+    # through the internal reader 2.11 added when it deprecated the
+    # public one. Which one is decided here, once.
+    if JSON3
+      def dump_defaults = JSON3_DUMP_DEFAULTS
+    elsif ::JSON.respond_to?(:_dump_default_options)
+      def dump_defaults = ::JSON._dump_default_options
+    else
+      def dump_defaults = ::JSON.dump_default_options
     end
   end
 end
@@ -101,16 +155,26 @@ module JSON
       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)
+      if NOSJ::JSONDropIn::JSON3
+        def parse(source, **opts)
+          if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::PARSE_OPTS)
+            NOSJ::JSONDropIn.parse(source, opts)
+          else
+            nosj_original_parse(source, **opts)
+          end
+        end
+      else
+        def parse(source, opts = nil)
+          if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::JSON2_PARSE_OPTS)
+            NOSJ::JSONDropIn.parse(source, NOSJ::JSONDropIn.without_quirks_mode(opts))
+          else
+            nosj_original_parse(source, opts)
+          end
         end
       end
 
       def generate(obj, opts = nil)
-        if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::GENERATE_OPTS)
+        if NOSJ::JSONDropIn.generate_supported?(opts)
           NOSJ::JSONDropIn.generate(obj, opts, false)
         else
           nosj_original_generate(obj, opts)
@@ -118,7 +182,7 @@ module JSON
       end
 
       def pretty_generate(obj, opts = nil)
-        if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::GENERATE_OPTS)
+        if NOSJ::JSONDropIn.generate_supported?(opts)
           NOSJ::JSONDropIn.generate(obj, opts, true)
         else
           nosj_original_pretty_generate(obj, opts)
@@ -127,17 +191,19 @@ module JSON
 
       def dump(obj, an_io = nil, limit = nil, kwargs = nil)
         # Fast path for the common shapes, dump(obj) and dump(obj, opts
-        # hash), mirroring gem json: dump defaults merged under the
-        # user's options, NestingError surfaced as ArgumentError. IO and
-        # limit arguments take gem json's own dump.
-        if limit.nil? && kwargs.nil? && (an_io.nil? || an_io.instance_of?(Hash))
-          opts = _dump_default_options
+        # hash): the installed gem's dump defaults merged under the
+        # caller's options. IO and limit arguments, and anything the
+        # fast path refuses, take gem json's own dump, which also turns
+        # json 2's NestingError into its ArgumentError.
+        if limit.nil? && kwargs.nil? &&
+            (an_io.nil? || NOSJ::JSONDropIn::DUMP_MERGES_OPTIONS && an_io.instance_of?(Hash))
+          opts = NOSJ::JSONDropIn.dump_defaults
           opts = opts.merge(an_io) if an_io
-          if NOSJ::JSONDropIn.supported?(opts, NOSJ::JSONDropIn::GENERATE_OPTS)
+          if NOSJ::JSONDropIn.generate_supported?(opts)
             begin
-              return NOSJ::JSONDropIn.generate(obj, opts, false)
-            rescue ::JSON::NestingError
-              raise ArgumentError, "exceed depth limit"
+              return NOSJ.generate(obj, opts)
+            rescue NOSJ::GeneratorError, NOSJ::NestingError
+              # the gem's own dump below runs it again and decides
             end
           end
         end

data/lib/nosj/version.rb

@@ -2,5 +2,5 @@
 
 module NOSJ
   # The gem version.
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end