nosj 0.2.0 → 0.3.1

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

@@ -23,7 +23,7 @@
 mod errors;
 mod hash_iter;
 mod keys;
-mod opts;
+pub(crate) mod opts;
 mod ruby;
 mod walker;
 
@@ -46,12 +46,17 @@ use walker::Gen;
 struct GenScratch {
     buf: Vec<u8>,
     keys: GenKeyCache,
+    /// Keys pre-escaped under HtmlSafe (the Rails encoder): cached
+    /// bytes bake in the escape mode, so each cacheable mode owns a
+    /// cache (see walker::mode_cacheable).
+    html_keys: GenKeyCache,
 }
 
 thread_local! {
     static GEN_SCRATCH: RefCell<GenScratch> = RefCell::new(GenScratch {
         buf: Vec::new(),
         keys: GenKeyCache::with_capacity(256),
+        html_keys: GenKeyCache::with_capacity(64),
     });
 }
 
@@ -86,6 +91,29 @@ pub fn generate_entry(ruby: &Ruby, _rb_self: Value, args: &[Value]) -> Result<RS
     generate_scratched(ruby, obj, cfg, cap_hint)
 }
 
+/// `NOSJ.generate_rails_native(obj, escape_html, escape_js)`: compact
+/// generation under ActiveSupport walk semantics (non-native values
+/// recurse through as_json, non-finite floats emit null). Every escape
+/// flag combination maps to a crate escape mode, so HTML/JS-safety
+/// escaping is always fused into the emission kernels: one pass, no
+/// post-processing. The Rails encoder installed by
+/// `require "nosj/rails"` is the only caller.
+pub fn generate_rails_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    obj: Value,
+    escape_html: bool,
+    escape_js: bool,
+) -> Result<RString, Error> {
+    let cfg = match (escape_html, escape_js) {
+        (true, true) => &opts::RAILS_HTML_SAFE_CONFIG,
+        (true, false) => &opts::RAILS_HTML_ENTITIES_CONFIG,
+        (false, true) => &opts::RAILS_JS_SEPARATORS_CONFIG,
+        (false, false) => &opts::RAILS_CONFIG,
+    };
+    generate_scratched(ruby, obj, cfg, 0)
+}
+
 /// `NOSJ.generate_native(obj, opts)`: the fixed-arity entry kept for
 /// the Ruby-level wrappers (pretty_generate merges options first).
 pub fn generate_native(
@@ -149,15 +177,18 @@ fn generate_scratched_into<R>(
     GEN_SCRATCH.with(|cell| match cell.try_borrow_mut() {
         Ok(mut scratch) => {
             let scratch = &mut *scratch;
-            generate_with(
-                ruby,
-                obj,
-                cfg,
-                cap_hint,
-                &mut scratch.buf,
-                &mut scratch.keys,
-                finish,
-            )
+            let GenScratch {
+                buf,
+                keys,
+                html_keys,
+                ..
+            } = scratch;
+            let keys = if cfg.mode == nosj::emit::EscapeMode::HtmlSafe {
+                html_keys
+            } else {
+                keys
+            };
+            generate_with(ruby, obj, cfg, cap_hint, buf, keys, finish)
         }
         Err(_) => {
             let mut buf = Vec::new();
@@ -180,7 +211,21 @@ fn generate_with<R>(
     if out.capacity() < cap_hint {
         out.reserve(cap_hint);
     }
+    emit_one(ruby, obj, cfg, out, keys)?;
+    finish(ruby, out)
+}
 
+/// Emit one value into `out` (appending, not clearing), mapping walker
+/// failures onto the gem's exceptions. `inline(always)`: this is the
+/// single-document hot path's only call layer.
+#[inline(always)]
+fn emit_one(
+    ruby: &Ruby,
+    obj: Value,
+    cfg: &opts::GenConfig,
+    out: &mut Vec<u8>,
+    keys: &mut GenKeyCache,
+) -> Result<(), Error> {
     let mut g = Gen {
         out,
         cfg,
@@ -193,9 +238,9 @@ fn generate_with<R>(
         g.emit_value::<false>(obj.as_raw(), cfg.start_depth)
     };
 
-    let Gen { out, fail, .. } = g;
+    let Gen { fail, .. } = g;
     match (result, fail) {
-        (Ok(()), None) => finish(ruby, out),
+        (Ok(()), None) => Ok(()),
         (_, Some(fail)) => Err(raise_fail(ruby, fail)),
         (Err(()), None) => Err(Error::new(
             ruby.exception_runtime_error(),
@@ -203,3 +248,102 @@ fn generate_with<R>(
         )),
     }
 }
+
+/// Emit one value into `out` under `cfg`, borrowing the pooled key
+/// cache. The splice/patch entries use this to generate replacement
+/// values straight into their output buffer.
+pub(crate) fn emit_into(
+    ruby: &Ruby,
+    obj: Value,
+    cfg: &opts::GenConfig,
+    out: &mut Vec<u8>,
+) -> Result<(), Error> {
+    GEN_SCRATCH.with(|cell| match cell.try_borrow_mut() {
+        Ok(mut scratch) => emit_one(ruby, obj, cfg, out, &mut scratch.keys),
+        Err(_) => emit_one(ruby, obj, cfg, out, &mut GenKeyCache::default()),
+    })
+}
+
+/// Formatting strings holding a newline (or carriage return) would
+/// split one value across NDJSON lines; the lines entries refuse them.
+fn breaks_line_framing(cfg: &opts::GenConfig) -> bool {
+    [
+        &cfg.indent,
+        &cfg.space,
+        &cfg.space_before,
+        &cfg.object_nl,
+        &cfg.array_nl,
+    ]
+    .into_iter()
+    .any(|v| v.iter().any(|&b| b == b'\n' || b == b'\r'))
+}
+
+/// `NOSJ.generate_lines_native(values, opts)`: NDJSON generation, one
+/// compact document per element into ONE pooled buffer, newline after
+/// each (every line terminated, per the format).
+pub fn generate_lines_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    values: magnus::RArray,
+    opts: Value,
+) -> Result<RString, Error> {
+    generate_lines_bytes_into(ruby, values, opts, finish_rstring)
+}
+
+/// The write-to-disk form of [`generate_lines_native`], used by
+/// `NOSJ.write_lines`.
+pub(crate) fn generate_lines_bytes_into<R>(
+    ruby: &Ruby,
+    values: magnus::RArray,
+    opts: Value,
+    finish: impl FnOnce(&Ruby, &[u8]) -> Result<R, Error>,
+) -> Result<R, Error> {
+    use magnus::value::ReprValue;
+    let built;
+    let (cfg, cap_hint): (&opts::GenConfig, usize) = if opts.is_nil() {
+        (&opts::DEFAULT_CONFIG, 0)
+    } else {
+        let (c, hint) = opts::parse_gen_opts(ruby, opts)?;
+        built = c;
+        (&built, hint)
+    };
+    if breaks_line_framing(cfg) {
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            "formatting options containing newlines would break JSON Lines framing",
+        ));
+    }
+    GEN_SCRATCH.with(|cell| match cell.try_borrow_mut() {
+        Ok(mut scratch) => {
+            let scratch = &mut *scratch;
+            let GenScratch { buf, keys, .. } = scratch;
+            generate_lines_with(ruby, values, cfg, cap_hint, buf, keys, finish)
+        }
+        Err(_) => {
+            let mut buf = Vec::new();
+            let mut keys = GenKeyCache::default();
+            generate_lines_with(ruby, values, cfg, cap_hint, &mut buf, &mut keys, finish)
+        }
+    })
+}
+
+fn generate_lines_with<R>(
+    ruby: &Ruby,
+    values: magnus::RArray,
+    cfg: &opts::GenConfig,
+    cap_hint: usize,
+    out: &mut Vec<u8>,
+    keys: &mut GenKeyCache,
+    finish: impl FnOnce(&Ruby, &[u8]) -> Result<R, Error>,
+) -> Result<R, Error> {
+    out.clear();
+    if out.capacity() < cap_hint {
+        out.reserve(cap_hint);
+    }
+    for i in 0..values.len() {
+        let obj: Value = values.entry(i as isize)?;
+        emit_one(ruby, obj, cfg, out, keys)?;
+        out.push(b'\n');
+    }
+    finish(ruby, out)
+}

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

@@ -5,18 +5,23 @@ use magnus::value::ReprValue;
 use magnus::{Error, RHash, RString, Ruby, Value};
 use nosj::emit::EscapeMode;
 
-pub(super) struct GenConfig {
-    pub(super) indent: Vec<u8>,
-    pub(super) space: Vec<u8>,
-    pub(super) space_before: Vec<u8>,
-    pub(super) object_nl: Vec<u8>,
-    pub(super) array_nl: Vec<u8>,
+pub(crate) struct GenConfig {
+    pub(crate) indent: Vec<u8>,
+    pub(crate) space: Vec<u8>,
+    pub(crate) space_before: Vec<u8>,
+    pub(crate) object_nl: Vec<u8>,
+    pub(crate) array_nl: Vec<u8>,
     /// 0 = unlimited.
     pub(super) max_nesting: usize,
     pub(super) start_depth: usize,
-    pub(super) allow_nan: bool,
+    pub(crate) allow_nan: bool,
     pub(super) strict: bool,
-    pub(super) mode: EscapeMode,
+    /// ActiveSupport walk semantics: non-native values recurse through
+    /// as_json instead of splicing to_json, and non-finite floats emit
+    /// null (Float#as_json parity). Set only by the Rails entry, never
+    /// from user option hashes.
+    pub(super) rails: 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,
@@ -27,7 +32,7 @@ pub(super) struct GenConfig {
 /// 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(super) static DEFAULT_CONFIG: GenConfig = GenConfig {
+pub(crate) static DEFAULT_CONFIG: GenConfig = GenConfig {
     indent: Vec::new(),
     space: Vec::new(),
     space_before: Vec::new(),
@@ -37,6 +42,78 @@ pub(super) static DEFAULT_CONFIG: GenConfig = GenConfig {
     start_depth: 0,
     allow_nan: false,
     strict: false,
+    rails: false,
+    mode: EscapeMode::Standard,
+    pretty: false,
+};
+
+/// 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,
+};
+
+/// 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,
+};
+
+/// 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,
+};
+
+/// 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,
 };
@@ -53,6 +130,7 @@ impl Default for GenConfig {
             start_depth: 0,
             allow_nan: false,
             strict: false,
+            rails: false,
             mode: EscapeMode::Standard,
             pretty: false,
         }
@@ -86,7 +164,7 @@ fn opt_bool(ruby: &Ruby, opts: RHash, name: &str) -> Option<bool> {
 
 /// Decode a non-nil options hash (nil takes [`DEFAULT_CONFIG`] at the
 /// call site without constructing anything).
-pub(super) fn parse_gen_opts(ruby: &Ruby, opts: Value) -> Result<(GenConfig, usize), Error> {
+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() {

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

@@ -23,6 +23,57 @@ 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.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).
+pub(super) fn protected_as_json(v: VALUE) -> Result<VALUE, Error> {
+    magnus::rb_sys::protect(|| unsafe { rb_sys::rb_funcall(v, as_json_id(), 0) })
+}
+
+/// Interned `as_json` method ID, resolved once per process.
+fn as_json_id() -> rb_sys::ID {
+    static AS_JSON: OnceLock<usize> = OnceLock::new();
+    *AS_JSON.get_or_init(|| unsafe { rb_sys::rb_intern(c"as_json".as_ptr()) } as usize)
+        as rb_sys::ID
+}
+
+/// Whether `v` is a `JSON::Fragment` (pre-rendered JSON to splice
+/// verbatim: the gem accepts fragments even under `strict`, and
+/// ActiveSupport's encoder passes them through). The class is resolved
+/// lazily and cached only on success, so a json gem loaded after the
+/// 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 {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    static FRAGMENT: AtomicUsize = AtomicUsize::new(0);
+    let mut cls = FRAGMENT.load(Ordering::Relaxed);
+    if cls == 0 {
+        cls = resolve_json_fragment();
+        if cls == 0 {
+            return false;
+        }
+        FRAGMENT.store(cls, Ordering::Relaxed);
+    }
+    unsafe { rb_sys::rb_obj_is_kind_of(v, cls as VALUE) != QFALSE }
+}
+
+fn resolve_json_fragment() -> usize {
+    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;
+        }
+        let json = 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;
+        }
+        rb_sys::rb_const_get(json, fragment_id) as usize
+    }
+}
+
 /// Encode `v` to UTF-8, protected. `rb_str_encode` raises on
 /// undefined/invalid conversions, matching the gem, which wraps that
 /// exception as GeneratorError (`rb_str_export_to_enc` is lenient and

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

@@ -3,7 +3,7 @@
 //! Compact and pretty modes are one const-generic body, so the compact
 //! hot path carries no formatting branches.
 
-use nosj::emit::{self, EscapeMode};
+use nosj::emit::{self, copy_short_raw, EscapeMode};
 use rb_sys::macros::{
     FIX2LONG, FIXNUM_P, FLONUM_P, RARRAY_CONST_PTR, RARRAY_LEN, RB_BUILTIN_TYPE, RHASH_SIZE,
     STATIC_SYM_P,
@@ -14,52 +14,16 @@ use super::errors::GenFail;
 use super::keys::GenKeyCache;
 use super::opts::GenConfig;
 use super::ruby::{
-    is_special_const, protected_encode_utf8, protected_to_json, protected_to_s, rstring_bytes,
-    str_coderange, str_enc_index, to_json_id, utf8_encindexes, CR_7BIT, CR_VALID, QFALSE, QNIL,
-    QTRUE,
+    is_json_fragment, is_special_const, protected_as_json, protected_encode_utf8,
+    protected_to_json, protected_to_s, rstring_bytes, str_coderange, str_enc_index, to_json_id,
+    utf8_encindexes, CR_7BIT, CR_VALID, QFALSE, QNIL, QTRUE,
 };
 
-/// Overlapping-word copy for short runs through a raw pointer (the
-/// crate's `copy_small` shape, local because that helper is
-/// crate-internal): a size-laddered pair of unaligned loads/stores
-/// instead of a libc memmove call, whose per-call overhead measured
-/// 42% on tiny-copy-heavy generation. Cached keys over 32 bytes are
-/// rare enough for the memcpy fallback.
-///
-/// # Safety
-///
-/// `n` readable bytes at `src`, `n` writable bytes at `dst`, and the
-/// ranges must not overlap.
-#[inline(always)]
-unsafe fn copy_short_raw(src: *const u8, dst: *mut u8, n: usize) {
-    /// One overlapping pair: word-size chunks at offset 0 and at
-    /// `n - size` cover `size..=2*size` bytes; the overlapped middle
-    /// is written twice with identical data.
-    macro_rules! word_pair {
-        ($t:ty) => {{
-            const SIZE: usize = size_of::<$t>();
-            dst.cast::<$t>()
-                .write_unaligned(src.cast::<$t>().read_unaligned());
-            dst.add(n - SIZE)
-                .cast::<$t>()
-                .write_unaligned(src.add(n - SIZE).cast::<$t>().read_unaligned());
-        }};
-    }
-    if n >= 16 {
-        if n <= 32 {
-            word_pair!(u128);
-        } else {
-            std::ptr::copy_nonoverlapping(src, dst, n);
-        }
-    } else if n >= 8 {
-        word_pair!(u64);
-    } else if n >= 4 {
-        word_pair!(u32);
-    } else if n >= 2 {
-        word_pair!(u16);
-    } else if n == 1 {
-        *dst = *src;
-    }
+/// Whether keys escaped under `mode` may be cached: the cached bytes
+/// bake in the escape mode, so the scratch keeps one cache per
+/// cacheable mode and hands `Gen` the matching one.
+pub(super) fn mode_cacheable(mode: EscapeMode) -> bool {
+    matches!(mode, EscapeMode::Standard | EscapeMode::HtmlSafe)
 }
 
 pub(super) struct Gen<'a> {
@@ -69,6 +33,7 @@ pub(super) struct Gen<'a> {
     pub(super) fail: Option<GenFail>,
     /// Pre-escaped key cache, borrowed for the whole document (one
     /// thread-local borrow per generate call instead of one per key).
+    /// Always the cache matching `cfg.mode` (see [`mode_cacheable`]).
     pub(super) keys: &'a mut GenKeyCache,
 }
 
@@ -149,6 +114,11 @@ impl Gen<'_> {
             emit::write_f64(&mut *self.out, f);
             return Ok(());
         }
+        if self.cfg.rails {
+            // ActiveSupport's Float#as_json: non-finite floats are null.
+            self.out.extend_from_slice(b"null");
+            return Ok(());
+        }
         let name = if f.is_nan() {
             "NaN"
         } else if f > 0.0 {
@@ -166,13 +136,14 @@ impl Gen<'_> {
     }
 
     /// Emit an object key from the pre-escaped cache. Only frozen string
-    /// keys in Standard escape mode are cacheable: frozen guarantees the
-    /// content behind the VALUE can't change, and the cached bytes bake in
-    /// the escape mode.
+    /// keys in a cacheable escape mode qualify: frozen guarantees the
+    /// content behind the VALUE can't change, and the cached bytes bake
+    /// in the escape mode, so each cacheable mode gets its own cache
+    /// instance from the scratch (see [`mode_cacheable`]).
     fn emit_key_cached(&mut self, k: VALUE) -> Result<(), ()> {
         const FL_FREEZE: u64 = rb_sys::ruby_fl_type::RUBY_FL_FREEZE as u64;
         let frozen = unsafe { (*(k as *const rb_sys::RBasic)).flags } & FL_FREEZE != 0;
-        if !frozen || self.cfg.mode != EscapeMode::Standard {
+        if !frozen || !mode_cacheable(self.cfg.mode) {
             return self.emit_rstring_quoted(k);
         }
         if let Some(bytes) = self.keys.get(k) {
@@ -190,13 +161,13 @@ impl Gen<'_> {
     }
 
     /// The pre-escaped bytes for `k` when the cache may serve it:
-    /// frozen string key, Standard escape mode (see [`Gen::emit_key_cached`]
-    /// for why only that combination is cacheable). An associated fn
-    /// over the split-out fields so callers keep `self.out` free.
+    /// frozen string key, cacheable escape mode (see
+    /// [`Gen::emit_key_cached`]). An associated fn over the split-out
+    /// fields so callers keep `self.out` free.
     #[inline(always)]
     fn cached_key_bytes<'k>(cfg: &GenConfig, keys: &'k GenKeyCache, k: VALUE) -> Option<&'k [u8]> {
         const FL_FREEZE: u64 = rb_sys::ruby_fl_type::RUBY_FL_FREEZE as u64;
-        if cfg.mode == EscapeMode::Standard
+        if mode_cacheable(cfg.mode)
             && !is_special_const(k)
             && unsafe { RB_BUILTIN_TYPE(k) } == ruby_value_type::RUBY_T_STRING
             && unsafe { (*(k as *const rb_sys::RBasic)).flags } & FL_FREEZE != 0
@@ -303,11 +274,20 @@ impl Gen<'_> {
         }
     }
 
-    /// Non-native type: strict raises; otherwise `to_json` if the object
-    /// responds (result appended verbatim), else `to_s` as a JSON string,
-    /// which is exactly what the gem's `Object#to_json` does.
-    fn emit_fallback(&mut self, raw: VALUE) -> Result<(), ()> {
+    /// Non-native type: strict raises (except `JSON::Fragment`, which
+    /// the gem splices even under strict); otherwise `to_json` if the
+    /// object responds (result appended verbatim), else `to_s` as a
+    /// JSON string, which is exactly what the gem's `Object#to_json`
+    /// does. Rails mode recurses through `as_json` instead
+    /// (JSONGemEncoder#jsonify).
+    fn emit_fallback<const PRETTY: bool>(&mut self, raw: VALUE, depth: usize) -> Result<(), ()> {
+        if self.cfg.rails {
+            return self.emit_rails_fallback::<PRETTY>(raw, depth);
+        }
         if self.cfg.strict {
+            if is_json_fragment(raw) {
+                return self.splice_to_json(raw);
+            }
             let name = unsafe {
                 std::ffi::CStr::from_ptr(rb_sys::rb_obj_classname(raw))
                     .to_string_lossy()
@@ -341,6 +321,64 @@ impl Gen<'_> {
         }
     }
 
+    /// Splice `raw`'s `to_json` result verbatim: the JSON::Fragment
+    /// path (pre-rendered JSON, trusted like the gem trusts it).
+    fn splice_to_json(&mut self, raw: VALUE) -> Result<(), ()> {
+        match protected_to_json(raw) {
+            Ok(json)
+                if !is_special_const(json)
+                    && unsafe { RB_BUILTIN_TYPE(json) } == ruby_value_type::RUBY_T_STRING =>
+            {
+                self.append_rstring_raw(json);
+                Ok(())
+            }
+            Ok(_) => {
+                self.fail = Some(GenFail::Generator(
+                    "JSON::Fragment#to_json did not return a String".to_string(),
+                ));
+                Err(())
+            }
+            Err(exc) => {
+                self.fail = Some(GenFail::Reraise(exc));
+                Err(())
+            }
+        }
+    }
+
+    /// Rails-mode fallback, mirroring JSONGemEncoder#jsonify:
+    /// fragments splice through (like ActiveSupport passes them to the
+    /// gem); everything else is asked for its as_json representation
+    /// (no arguments; only the top-level value receives the encoder
+    /// options), which is emitted in its place. An as_json returning
+    /// the receiver would recurse forever, so it raises instead.
+    fn emit_rails_fallback<const PRETTY: bool>(
+        &mut self,
+        raw: VALUE,
+        depth: usize,
+    ) -> Result<(), ()> {
+        if is_json_fragment(raw) {
+            return self.splice_to_json(raw);
+        }
+        match protected_as_json(raw) {
+            Ok(json) if json == raw => {
+                let name = unsafe {
+                    std::ffi::CStr::from_ptr(rb_sys::rb_obj_classname(raw))
+                        .to_string_lossy()
+                        .into_owned()
+                };
+                self.fail = Some(GenFail::Generator(format!(
+                    "{name}#as_json returned the receiver"
+                )));
+                Err(())
+            }
+            Ok(json) => self.emit_value::<PRETTY>(json, depth),
+            Err(exc) => {
+                self.fail = Some(GenFail::Reraise(exc));
+                Err(())
+            }
+        }
+    }
+
     fn nesting_check(&mut self, inner: usize) -> Result<(), ()> {
         if self.cfg.max_nesting > 0 && inner > self.cfg.max_nesting {
             self.fail = Some(GenFail::Nesting(self.cfg.max_nesting));
@@ -601,7 +639,7 @@ impl Gen<'_> {
                     let s = unsafe { rb_sys::rb_sym2str(raw) };
                     self.emit_rstring_quoted(s)
                 }
-                _ => self.emit_fallback(raw),
+                _ => self.emit_fallback::<PRETTY>(raw, depth),
             };
         }
         if FIXNUM_P(raw) {
@@ -633,6 +671,6 @@ impl Gen<'_> {
             let s = unsafe { rb_sys::rb_sym2str(raw) };
             return self.emit_rstring_quoted(s);
         }
-        self.emit_fallback(raw)
+        self.emit_fallback::<PRETTY>(raw, depth)
     }
 }