yeptris 0.6.33.1 → 0.6.33.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8b675b39f6785429f94719e6181385b944307a0d0ffa4ce110e632ff6a32376
-  data.tar.gz: e9adc21e40e03957bbabc17b6a05ff14b45407d8e664cf4010f40a5696cb2369
+  metadata.gz: 5c8387634db975646ba93194c5b420eaee60e63b2c5d1e7e1792820f4466fe63
+  data.tar.gz: e57d53e6242a6cd3ba4f176785800a4ac5864cb93bdd79ff838f23f926068531
 SHA512:
-  metadata.gz: 3321c98a84e187037ccf67af14fef2a4ea0ec2570c2d5f9ffb962ba9199959a8d1cefdbf146963cc208536cbfc575c012078548226456f3ac7f485f91a44f897
-  data.tar.gz: 255ae290f8227e62f026629a5ee69666535c0442fa167877223cbc0cbe2d9ce74398b98c75f706a370765714fe5694fc2b3b165f0539a7ffd8c5e931080092de
+  metadata.gz: 84b3b33511828a97084d720e53dda58d4a8aa64b51993bc48aa76cca773844ce86758d0f41d053abf2849c8e5c77c22a5f9ba06f6f797b96783c966233d699a9
+  data.tar.gz: 5499a1cb92292591025abe0a89406fb6ba4a427876cc08d171ad7a554da3cfdebf0d0ba79762f05d6a9e01853082348376c2d5d6125445ceed74218f279181fa

data/README.adoc

@@ -5,6 +5,15 @@ https://github.com/leptris/yeptris[libyeptris] — the YAML counterpart
 of libleptris. Psych-compatible semantics, one shared library, zero
 compilation at install.
 
+Part of the yeptris program: *the best (multiple dimensions)
+YAML/JSON parser/builder ever* — conformance, performance,
+safety/hardening, API surfaces, transport correctness, and trust,
+held simultaneously, in C, Ruby, Rust, and JS. This binding is the
+most complete surface: the Psych drop-in namespace, JSON.parse
+parity with the strict duplicate-key contract, CBOR, and ValueML,
+tracking every libyeptris release in lockstep. The achievement
+program lives in the engine's PLAN.md ("The best-ever program").
+
 == Install (development)
 
 The gem loads a shared `libyeptris` — from `YEPTRIS_LIB_PATH`, a

data/ext/yeptris_native/json_ruby.c

@@ -173,9 +173,19 @@ static VALUE jr_object(jr* j) {
 }
 
 static VALUE jr_object_body(jr* j, VALUE h_pre) {
+    /* The pairs staging buffer MUST live in GC-scanned memory: pairs
+     * beyond the current one exist only there once the key/val locals
+     * are reused, so a malloc'd buffer makes them invisible to the
+     * collector — it can free them mid-parse and recycle their slots,
+     * and rb_hash_bulk_insert then inserts garbage (yeptris-ruby#279:
+     * the arm64-darwin SIGSEGV whose fault address was document text).
+     * The stack array IS scanned, so the bulk fast path is bounded at
+     * 31 pairs; beyond that the buffered pairs flush with one
+     * bulk_insert and the rest of the object rides rb_hash_aset. */
     VALUE pairs[64];
     VALUE* pv = pairs;
     size_t pcap = 64, pn = 0, heap_cap = 0;
+    int aset_rest = 0;
     for (;;) {
         jr_ws(j);
         if (j->i >= j->len || j->p[j->i] != '"') { j->err = -2; goto out; }
@@ -186,7 +196,7 @@ static VALUE jr_object_body(jr* j, VALUE h_pre) {
         j->i++;
         VALUE val = jr_value(j);
         if (j->err) goto out;
-        if (yep_ins_mode == YEP_INS_ASET || j->strict_dup) {
+        if (yep_ins_mode == YEP_INS_ASET || j->strict_dup || aset_rest) {
             VALUE h = h_pre == Qundef ? (h_pre = HASH_NEW_CAPA(8)) : h_pre;
             if (j->strict_dup && !NIL_P(rb_hash_aref(h, key))) {
                 j->err = -3;
@@ -196,15 +206,21 @@ static VALUE jr_object_body(jr* j, VALUE h_pre) {
             rb_hash_aset(h, key, val);
         } else {
             if (pn + 2 > pcap) {
-                size_t ncap = pcap * 2;
-                VALUE* nv = malloc(ncap * sizeof(VALUE));
-                if (!nv) { j->err = -1; goto out; }
-                memcpy(nv, pv, pn * sizeof(VALUE));
-                if (pv != pairs) { free(pv); heap_cap = 1; }
-                pv = nv; pcap = ncap;
+                /* buffer full: flush what is staged (no heap staging —
+                 * see the #279 note above); THIS pair and the rest of
+                 * the object ride aset — no continue here, the
+                 * delimiter scan below must still run */
+                VALUE h = (h_pre == Qundef) ? (h_pre = HASH_NEW_CAPA((long)(pn / 2) + 8)) : h_pre;
+                rb_hash_bulk_insert((long)pn, (const VALUE*)pv, h);
+                pn = 0;
+                aset_rest = 1;
+            }
+            if (aset_rest) {
+                rb_hash_aset(h_pre, key, val);
+            } else {
+                pv[pn++] = key;
+                pv[pn++] = val;
             }
-            pv[pn++] = key;
-            pv[pn++] = val;
         }
         jr_ws(j);
         if (j->i >= j->len) { j->err = -2; goto out; }
@@ -351,7 +367,17 @@ double yep_rb_scan_time(const char* p, size_t len, int n) {
 VALUE yep_rb_parse_json(const char* p, size_t len, int strict_dup) {
     jr j;
     memset(&j, 0, sizeof(j));
-    j.p = p; j.len = len; j.enc = rb_utf8_encoding();
+    /* The parse holds j.p across unbounded allocations, and the GC
+     * strategy knobs leave collection ENABLED during the window
+     * (arm64's default is none). A compaction moving the source
+     * string would dangle every j->p read after the move
+     * (yeptris-ruby#279's heap-layout-dependent SIGSEGV class), so
+     * the parse runs on a private copy: one memcpy of the input,
+     * then no Ruby object backs the cursor. */
+    char* own = malloc(len ? len : 1);
+    if (own == NULL) rb_raise(rb_eNoMemError, "yeptris native json");
+    memcpy(own, p, len);
+    j.p = own; j.len = len; j.enc = rb_utf8_encoding();
     j.strict_dup = strict_dup;
     VALUE already = Qtrue;
     if (yep_gc_mode != YEP_GC_NONE) already = rb_gc_disable();
@@ -359,6 +385,7 @@ VALUE yep_rb_parse_json(const char* p, size_t len, int strict_dup) {
     jr_ws(&j);
     if (j.i != len && j.err == 0) j.err = -2;
     free(j.scratch);
+    free(own);
     if (already == Qfalse) rb_gc_enable();
     if (yep_gc_mode == YEP_GC_START && j.err == 0) rb_gc_start();
     if (j.err == -1) rb_raise(rb_eNoMemError, "yeptris native json");
@@ -366,6 +393,11 @@ VALUE yep_rb_parse_json(const char* p, size_t len, int strict_dup) {
         rb_raise(rb_path2class("Yeptris::ParseError"), "duplicate key \"%s\" in JSON object",
                  RSTRING_PTR(j.dup_key));
     }
-    if (j.err != 0) rb_raise(rb_path2class("Yeptris::ParseError"), "native json parse failed");
+    if (j.err != 0) {
+        /* the tape engine's wording ("not strict JSON at byte N") so
+         * consumers can pin one error shape across both routes
+         * (yeptris-ruby#279's adjacent note) */
+        rb_raise(rb_path2class("Yeptris::ParseError"), "not strict JSON at byte %zu", j.i);
+    }
     return v;
 }

data/lib/yeptris/ffi.rb

@@ -228,12 +228,17 @@ module Yeptris
                     %i[pointer size_t int int pointer pointer], :int
     attach_function :yeptris_marshal_node,
                     %i[yeptris_node pointer pointer], :int
+    attach_function :yeptris_marshal_node_ex,
+                    %i[yeptris_node uint32 pointer pointer], :int
     attach_function :yeptris_marshal_free, [:pointer], :void
     # The bulk child drain (#168's quadratic): O(n) iteration for
     # #each/#each_pair. Engines without it fall back to the per-index
     # walk (correct, quadratic).
     CHILDREN_DRAIN = !(@missing ||= []).include?(:yeptris_node_children)
     MARSHAL = !(@missing ||= []).include?(:yeptris_marshal_node)
+    # the strict-dup marshal entry (engine 0.6.34+, yeptris-ruby#278):
+    # gates the JSON fallback's C route in STRICT mode
+    MARSHAL_STRICT_DUP = !(@missing ||= []).include?(:yeptris_marshal_node_ex)
 
     # bulk build (TODO.impl/15 phase D): one call raises a document
     BUILD_SCALAR = 1

data/lib/yeptris/json.rb

@@ -9,10 +9,13 @@ module Yeptris
   # keeps the Psych contract for every input (JSON-shaped included),
   # so the two never drift into each other's semantics.
   #
-  # Engines, fastest first (both exact — the parity spec runs against
+  # Engines, fastest first (all exact — the parity spec runs against
   # whichever is loaded):
   # 1. the native materializer (fused C scan → VALUE; opt-in build)
-  # 2. the record drain + strict conversion walk (always available)
+  # 2. the marshal engine (#278): strict-JSON parse + Marshal 4.8
+  #    emission + ONE core Marshal.load — all C, no per-value Ruby
+  #    (engine 0.6.34+; the strict flag follows the resolved json gem)
+  # 3. the record drain + strict conversion walk (always available)
   module JSON
     class Error < ::Yeptris::Error; end
     class ParseError < Error; end
@@ -39,9 +42,46 @@ module Yeptris
           raise ParseError, e.message
         end
       end
+      # yeptris-ruby#278: with no Ruby-version-matched native build the
+      # pure-Ruby walk measured 0.11x vs JSON.parse on real documents —
+      # the marshal engine keeps the fallback C-side end to end.
+      return marshal_engine(source, 0) if ::Yeptris::FFI::MARSHAL_STRICT_DUP
       tape_engine(source)
     end
 
+    # The marshal engine (#278): yeptris_parse_json gates the strict
+    # grammar, yeptris_marshal_node_ex writes the Ruby Marshal 4.8
+    # stream (STRICT_DUP_KEYS raising on json 3's default contract),
+    # and ONE core Marshal.load materializes the graph. Returns nil
+    # when the engine cannot serve the route (caller keeps walking);
+    # every parse/dup failure raises ParseError.
+    def marshal_engine(source, flags)
+      begin
+        gate = ::Yeptris::Document.parse_json(source)
+      rescue ::Yeptris::ParseError => e
+        raise ParseError, e.message
+      end
+      begin
+        out_p = ::FFI::MemoryPointer.new(:pointer)
+        olen_p = ::FFI::MemoryPointer.new(:size_t)
+        st = ::Yeptris::FFI.yeptris_marshal_node_ex(
+          ::Yeptris::FFI.yeptris_document_root(gate.c_ptr, 0), flags, out_p, olen_p
+        )
+        if st != ::Yeptris::FFI::OK
+          raise ParseError, ::Yeptris::FFI.last_error_message if st == ::Yeptris::FFI::ERROR_PARSE
+
+          return nil # UNSUPPORTED: merge keys et al. cannot occur in JSON
+        end
+        buf = out_p.read_pointer
+        data = buf.read_bytes(::Yeptris::FFI.read_c_size_t(olen_p))
+        data.force_encoding(Encoding::ASCII_8BIT)
+        ::Yeptris::FFI.yeptris_marshal_free(buf)
+        Marshal.load(data)
+      ensure
+        gate.free
+      end
+    end
+
     # The tape engine (issue #81): ONE call validates and materializes
     # the record stream; the walk reads four bulk columns and slices
     # strings straight out of the caller's source — no gate document,
@@ -212,6 +252,12 @@ module Yeptris
         raise ParseError, e.message
       end
       begin
+        if ::Yeptris::FFI::MARSHAL_STRICT_DUP
+          routed = marshal_engine(
+            source, STRICT_DUPLICATE_KEYS ? ::Yeptris::FFI::MARSHAL_STRICT_DUP_KEYS : 0
+          )
+          return routed unless routed.nil?
+        end
         cols = ::Yeptris::FFI::ValueColumns.new
         st = ::Yeptris::FFI.yeptris_value_drain_columns(
           source, source.bytesize, ::Yeptris::FFI::SCHEMA_12_CORE, cols

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.6.33.1".freeze
+  VERSION = "0.6.33.2".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.33.1
+  version: 0.6.33.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-19 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi