nosj 0.1.0 → 0.3.0

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(
@@ -102,45 +130,102 @@ pub fn generate_native(
     generate_scratched(ruby, obj, &cfg, cap_hint)
 }
 
+/// Generate `obj` under a Ruby options hash (or nil) and hand the
+/// finished bytes to `finish` instead of building a Ruby String: the
+/// entry `NOSJ.write_file` uses to stream straight to disk.
+pub(crate) fn generate_bytes_into<R>(
+    ruby: &Ruby,
+    obj: Value,
+    opts: Value,
+    finish: impl FnOnce(&Ruby, &[u8]) -> Result<R, Error>,
+) -> Result<R, Error> {
+    use magnus::value::ReprValue;
+    if opts.is_nil() {
+        return generate_scratched_into(ruby, obj, &opts::DEFAULT_CONFIG, 0, finish);
+    }
+    let (cfg, cap_hint) = opts::parse_gen_opts(ruby, opts)?;
+    generate_scratched_into(ruby, obj, &cfg, cap_hint, finish)
+}
+
 fn generate_scratched(
     ruby: &Ruby,
     obj: Value,
     cfg: &opts::GenConfig,
     cap_hint: usize,
 ) -> Result<RString, Error> {
+    generate_scratched_into(ruby, obj, cfg, cap_hint, finish_rstring)
+}
+
+/// The default finisher: the generated bytes as a Ruby String.
+fn finish_rstring(_ruby: &Ruby, out: &[u8]) -> Result<RString, Error> {
+    Ok(unsafe {
+        RString::from_value(Value::from_raw(rb_sys::rb_utf8_str_new(
+            out.as_ptr().cast(),
+            out.len() as std::os::raw::c_long,
+        )))
+        .expect("rb_utf8_str_new returns a String")
+    })
+}
+
+fn generate_scratched_into<R>(
+    ruby: &Ruby,
+    obj: Value,
+    cfg: &opts::GenConfig,
+    cap_hint: usize,
+    finish: impl FnOnce(&Ruby, &[u8]) -> Result<R, Error>,
+) -> Result<R, Error> {
     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,
-            )
+            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();
             let mut keys = GenKeyCache::default();
-            generate_with(ruby, obj, cfg, cap_hint, &mut buf, &mut keys)
+            generate_with(ruby, obj, cfg, cap_hint, &mut buf, &mut keys, finish)
         }
     })
 }
 
-fn generate_with(
+fn generate_with<R>(
     ruby: &Ruby,
     obj: Value,
     cfg: &opts::GenConfig,
     cap_hint: usize,
     out: &mut Vec<u8>,
     keys: &mut GenKeyCache,
-) -> Result<RString, Error> {
+    finish: impl FnOnce(&Ruby, &[u8]) -> Result<R, Error>,
+) -> Result<R, Error> {
     out.clear();
     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,
@@ -153,15 +238,9 @@ fn generate_with(
         g.emit_value::<false>(obj.as_raw(), cfg.start_depth)
     };
 
-    let Gen { out, fail, .. } = g;
+    let Gen { fail, .. } = g;
     match (result, fail) {
-        (Ok(()), None) => Ok(unsafe {
-            RString::from_value(Value::from_raw(rb_sys::rb_utf8_str_new(
-                out.as_ptr().cast(),
-                out.len() as std::os::raw::c_long,
-            )))
-            .expect("rb_utf8_str_new returns a String")
-        }),
+        (Ok(()), None) => Ok(()),
         (_, Some(fail)) => Err(raise_fail(ruby, fail)),
         (Err(()), None) => Err(Error::new(
             ruby.exception_runtime_error(),
@@ -169,3 +248,102 @@ fn generate_with(
         )),
     }
 }
+
+/// 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(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