nosj 0.2.0 → 0.3.0

data/ext/nosj/src/files.rs

@@ -17,9 +17,10 @@ use std::io::Read;
 use magnus::value::ReprValue;
 use magnus::{Error, RArray, RString, Ruby, Value};
 
+use crate::errors::{parser_error_at, runtime_error};
 use crate::gen;
 use crate::lazy::{self, DocBytes};
-use crate::parse::{err, materialize, parse_native_opts, ParseNativeOpts};
+use crate::parse::{err, materialize, materialize_at, parse_native_opts, span_of, ParseNativeOpts};
 use crate::pointer::path_to_pointer;
 use crate::state::PULL_STATE;
 
@@ -60,16 +61,16 @@ fn errno_of(e: &std::io::Error) -> Option<i32> {
 fn io_error(ruby: &Ruby, path: &str, e: &std::io::Error) -> Error {
     use magnus::rb_sys::FromRawValue;
     let Some(errno) = errno_of(e) else {
-        return err(ruby, format!("{e} - {path}"));
+        return runtime_error(ruby, format!("{e} - {path}"));
     };
     let Ok(cpath) = std::ffi::CString::new(path) else {
-        return err(ruby, format!("{e} - {path}"));
+        return runtime_error(ruby, format!("{e} - {path}"));
     };
     // SAFETY: rb_syserr_new returns a live Errno exception instance.
     let exc = unsafe { Value::from_raw(rb_sys::rb_syserr_new(errno, cpath.as_ptr())) };
     match magnus::Exception::from_value(exc) {
         Some(exc) => exc.into(),
-        None => err(ruby, format!("{e} - {path}")),
+        None => runtime_error(ruby, format!("{e} - {path}")),
     }
 }
 
@@ -128,8 +129,26 @@ pub fn write_file_native(
     })
 }
 
+/// `NOSJ.write_lines(path, values, opts)`: generate NDJSON (one
+/// document per element, newline-terminated) and write the bytes
+/// straight from the generator's pooled buffer. Returns the byte
+/// count, like `File.write`.
+pub fn write_lines_native(
+    ruby: &Ruby,
+    _rb_self: Value,
+    path: RString,
+    values: magnus::RArray,
+    opts: Value,
+) -> Result<usize, Error> {
+    let p = path.to_string()?;
+    gen::generate_lines_bytes_into(ruby, values, opts, |ruby, bytes| {
+        fs::write(&p, bytes).map_err(|e| io_error(ruby, &p, &e))?;
+        Ok(bytes.len())
+    })
+}
+
 /// Map `path` read-only and hand a UTF-8-checked view to `f`.
-fn with_mapped_file<R>(
+pub(crate) fn with_mapped_file<R>(
     ruby: &Ruby,
     path: &str,
     f: impl FnOnce(memmap2::Mmap) -> Result<R, Error>,
@@ -178,11 +197,14 @@ fn resolve_file_pointer(
         });
         match resolved {
             Ok(None) => Ok(ruby.qnil().as_value()),
-            Ok(Some(slice)) => materialize(ruby, slice.as_bytes(), o),
+            Ok(Some(slice)) => {
+                let (start, end) = span_of(&map, slice.as_bytes());
+                materialize_at(ruby, &map, start, end, o)
+            }
             Err(e) if matches!(e.kind, nosj::ErrorKind::InvalidPointer) => {
                 Err(Error::new(ruby.exception_arg_error(), e.to_string()))
             }
-            Err(e) => Err(err(ruby, e.to_string())),
+            Err(e) => Err(parser_error_at(ruby, &map, e.offset, e.to_string())),
         }
     })
 }

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

@@ -5,9 +5,10 @@
 use magnus::error::ErrorType;
 use magnus::rb_sys::AsRawValue;
 use magnus::value::ReprValue;
-use magnus::{Error, ExceptionClass, Module, RModule, Ruby};
+use magnus::{Error, Ruby};
 
 use super::ruby::rstring_bytes;
+use crate::errors::nosj_exception;
 
 pub(super) enum GenFail {
     /// Re-raise a Ruby exception captured by a protected call (user
@@ -22,14 +23,6 @@ pub(super) enum GenFail {
     Nesting(usize),
 }
 
-fn nosj_exception(ruby: &Ruby, name: &str) -> ExceptionClass {
-    let lookup = || -> Result<ExceptionClass, Error> {
-        let m: RModule = ruby.define_module("NOSJ")?;
-        m.const_get(name)
-    };
-    lookup().unwrap_or_else(|_| ruby.exception_runtime_error())
-}
-
 /// The exception's `to_s` (its message), matching what the gem embeds
 /// when it wraps a secondary exception.
 fn error_message(err: &Error) -> String {

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(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