yeptris 0.6.50.0-aarch64-linux → 0.6.51.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0782e25e15d541b7a7e5448f7c63e79e627a130946d131860133021262d15c28'
-  data.tar.gz: daf5279398e226c9ab663ab1482356938a675a7cdd84b0e872134e2f6651322f
+  metadata.gz: cc1eca4788a46d1ba98920b9611fa8bde1bdb99533ac54e6ee19ac24658d8472
+  data.tar.gz: 8c53810f5df811d36759d3bf93de7fd66e09c5097dafa44aa29c5914986f87aa
 SHA512:
-  metadata.gz: 423942744e7c5fbaa2c7dc4cde3f088abaf4aaacb88e4095c9e0fd0af1e3bf9774024522fcaa34d97e511ddba3b62e30a53753ee127a50ee3727f2a08fa08ca2
-  data.tar.gz: 102f3c0f8f3baa9d78ea65a3124c24c632d8f2e8940835e63c28061c81cb5b16039be3ac8c58e1751943ba3d10ef8287ee245260eb81b8a0a5b3d3a3ee63527e
+  metadata.gz: f6509bbdc7bc0aedd02afd6958beb3ed1dd9b99ec332a8337478ba6c39b7b8e42ad020cb7e87184168eee519a42a62d819d57dbf02e71431b445b883c47f9bb1
+  data.tar.gz: b95ac44576842182cd6a28aae11d532b4b11b8c10606ae8c666e562b5749d440dd65665208e4b533444f2041914be27389649d0d33aaf734d6cb9663f5750b26

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 50
-#define YEPTRIS_VERSION_STRING "0.6.50"
+#define YEPTRIS_VERSION_PATCH 51
+#define YEPTRIS_VERSION_STRING "0.6.51"
 
 #ifdef __cplusplus
 extern "C" {

data/lib/yeptris/json.rb

@@ -34,12 +34,21 @@ module Yeptris
 
     module_function
 
-    def load(source)
+    # allow_duplicate_key: opts out of the resolved json gem's strict
+    # duplicate-key contract (json >= 3 rejects by default) — last value
+    # wins, exactly the historical JSON.parse contract. System-boundary
+    # parsers need it: third-party feeds (Crossref book records keyed by
+    # ISBN, NIST's pubs export keyed by "&nbsp", the UN search API's blank
+    # keys) genuinely carry duplicates, and rejecting them breaks the fetch
+    # rather than flagging the data (relaton/relaton#413, the ask in
+    # yeptris-ruby#335). Default stays the json-gem-parity strictness.
+    def load(source, allow_duplicate_key: false)
+      strict = STRICT_DUPLICATE_KEYS && !allow_duplicate_key
       source = ::Yeptris.read_input(source)
       source = source.to_s
       if defined?(::Yeptris::Native)
         begin
-          return ::Yeptris::Native.load_json(source, STRICT_DUPLICATE_KEYS)
+          return ::Yeptris::Native.load_json(source, strict)
         rescue ::Yeptris::ParseError => e
           raise ParseError, e.message
         end
@@ -53,9 +62,9 @@ module Yeptris
       # none) answered last-wins under json >= 3 — found by canon's
       # dependent CI, whose parity pin now names the lane.
       return marshal_engine(
-        source, STRICT_DUPLICATE_KEYS ? ::Yeptris::FFI::MARSHAL_STRICT_DUP_KEYS : 0
+        source, strict ? ::Yeptris::FFI::MARSHAL_STRICT_DUP_KEYS : 0
       ) if ::Yeptris::FFI::MARSHAL_STRICT_DUP
-      tape_engine(source)
+      tape_engine(source, strict)
     end
 
     # The marshal engine (#278): yeptris_parse_json gates the strict
@@ -156,19 +165,19 @@ module Yeptris
       out.force_encoding(Encoding::UTF_8)
     end
 
-    def tape_engine(source)
+    def tape_engine(source, strict_dup = STRICT_DUPLICATE_KEYS)
       tape = ::Yeptris::FFI::JsonTape.new
       rc = ::Yeptris::FFI.yeptris_parse_json_tape(source, source.bytesize, tape)
       raise ParseError, ::Yeptris::FFI.last_error_message if rc != ::Yeptris::FFI::OK
 
       begin
-        walk_tape(source, tape)
+        walk_tape(source, tape, strict_dup)
       ensure
         ::Yeptris::FFI.yeptris_tape_free(tape)
       end
     end
 
-    def walk_tape(src, tape, strict_dup = STRICT_DUPLICATE_KEYS)
+    def walk_tape(src, tape, strict_dup)
       n = tape[:count]
       kinds = tape[:kinds].read_bytes(n).unpack("C*")
       offs = tape[:offs].read_bytes(n * 4).unpack("V*")

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.50.0".freeze
+  VERSION = "0.6.51.0".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.50
+    VERSION 0.6.51
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/include/yeptris/cbor.h

@@ -53,6 +53,55 @@ extern "C" {
 YEPTRIS_API YeptrisDocument yeptris_cbor_decode(const void* buf, size_t len, uint32_t opts,
                                                 YeptrisStatus* status);
 
+/* The SAX decode face (#742): yeptris_cbor_decode's grammar driving
+ * consumer callbacks — items land as they parse, no document, no
+ * nodes. Measured (perf ledger 2026-10-29): the scan-only route reads
+ * ~2.1x the DOM entry on the same corpus (DOM construction is over
+ * half the decode lane), so validation, counting, and streaming
+ * transforms belong here. Items arrive in encoding order; map items
+ * set is_key on the key half. Strings with borrowed=1 point INTO buf —
+ * keep it valid while you hold them; borrowed=0 is decoder scratch.
+ * tag ("N N N", outermost first; NULL when none) and tag_len are
+ * callback-call-local. open's cap is the expected item count (maps
+ * count pairs*2; UINT64_MAX = indefinite); close fires for both the
+ * definite-complete and the break path, after the last child. The
+ * rendered text forms match the DOM ledger exactly (numbers-as-text,
+ * false/true/null/undefined, simple(N)).
+ *
+ * Every callback returns 0 on sink failure — the decode then reports
+ * YEPTRIS_ERROR_MEMORY — and may raise through host languages; the
+ * decoder owns no host state across them except the indefinite buffer,
+ * which its own exit paths free. All seven callbacks and sax itself
+ * must be non-NULL (YEPTRIS_ERROR_ARG otherwise): the loop dispatches
+ * unconditionally.
+ *
+ * consumed == NULL: trailing bytes after the one data item fail
+ * YEPTRIS_ERROR_PARSE. consumed != NULL: on success it receives the
+ * byte count of the items decoded — walk a CBOR Sequence (RFC 8742)
+ * by advancing buf by it. On failure *status (may be NULL) carries the
+ * code and yeptris_last_error() the message with the byte offset.
+ *
+ * Memory: none — the decoder allocates only its indefinite-chunk
+ * scratch and frees it on every exit. */
+typedef struct yeptris_cbor_sax {
+    void* ctx;
+    int (*text)(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key, const char* tag,
+                uint32_t tag_len);
+    int (*int_val)(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
+                   uint32_t tag_len);
+    int (*float_val)(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len);
+    int (*str_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                   const char* tag, uint32_t tag_len);
+    int (*bytes_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                     const char* tag, uint32_t tag_len);
+    int (*open)(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len);
+    int (*close)(void* ctx, int is_map);
+} yeptris_cbor_sax;
+
+YEPTRIS_API YeptrisStatus yeptris_cbor_decode_sax(const void* buf, size_t len, uint32_t opts,
+                                                  const yeptris_cbor_sax* sax, size_t* consumed,
+                                                  YeptrisStatus* status);
+
 /* CBOR Sequences (RFC 8742): top-level data items, concatenated —
  * no framing bytes. Iterates the buffer, one document per item; the
  * callback OWNS each item (free it with yeptris_document_free) and

data/vendor/libyeptris/src/yeptris/cbor/decode.c

@@ -1032,3 +1032,25 @@ YEPTRIS_API YeptrisDocument yeptris_cbor_decode(const void* buf, size_t len, uin
     }
     return (YeptrisDocument)doc;
 }
+
+YEPTRIS_API YeptrisStatus yeptris_cbor_decode_sax(const void* buf, size_t len, uint32_t opts,
+                                                  const yeptris_cbor_sax* sax, size_t* consumed,
+                                                  YeptrisStatus* status) {
+    if ((buf == NULL && len != 0) || sax == NULL || (opts & ~YEPTRIS_CBOR_STRICT) != 0 ||
+        sax->text == NULL || sax->int_val == NULL || sax->float_val == NULL ||
+        sax->str_val == NULL || sax->bytes_val == NULL || sax->open == NULL || sax->close == NULL) {
+        if (status != NULL) {
+            *status = YEPTRIS_ERROR_ARG;
+        }
+        return YEPTRIS_ERROR_ARG;
+    }
+    /* yeptris_cbor_sax IS yep_cbor_sink (sink.h aliases the public
+     * face): the decoder drives the caller's vtable directly. */
+    YeptrisStatus st = (YeptrisStatus)yep_cbor_decode_gen((const unsigned char*)buf, len,
+                                                          (opts & YEPTRIS_CBOR_STRICT) != 0,
+                                                          consumed, (const yep_cbor_sink*)sax);
+    if (status != NULL) {
+        *status = st;
+    }
+    return st;
+}

data/vendor/libyeptris/src/yeptris/cbor/sink.h

@@ -4,7 +4,11 @@
  * source of CBOR semantics; a sink implements the item constructors
  * on top of it. Two sinks exist: the DOM builder (the default, the
  * yeptris_cbor_decode public path) and the native ext's VALUE builder
- * (one pass, no intermediate). Sinks receive the resolver's tag_id
+ * (one pass, no intermediate). The sink vtable IS the public SAX face
+ * (yeptris_cbor_sax, <yeptris/cbor.h> — #742): the alias keeps the
+ * decoder driving the same layout the public entry hands over, so
+ * yeptris_cbor_decode_sax is a straight passthrough. Callback/field
+ * contracts are documented there; sinks receive the resolver's tag_id
  * and the pending semantic-tag chain in its text form ("N N N",
  * outermost first — NULL when the item carries no chain).
  */
@@ -15,35 +19,9 @@
 #include <stdint.h>
 
 #include <yeptris/api.h> /* YEPTRIS_API (the ext links these) */
+#include <yeptris/cbor.h>
 
-typedef struct yep_cbor_sink {
-    void* ctx;
-    /* All callbacks return 0 on sink failure (the decoder reports
-     * MEMORY). They may raise through host languages (longjmp): the
-     * decoder owns no host-managed state across them except the
-     * indefinite buffer, which its own exit paths free. */
-    /* is_key: 1 = the item lands in the enclosing map's key slot
-     * (sinks key-intern strings; the DOM ignores it). Rendered text:
-     * numbers-as-text, false/true/null/undefined, simple(N) — the
-     * exact bytes the DOM path stores. */
-    int (*text)(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key, const char* tag,
-                uint32_t tag_len);
-    /* Known integers: value = negative ? -(mag) : mag, mag <= 2^63. */
-    int (*int_val)(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
-                   uint32_t tag_len);
-    int (*float_val)(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len);
-    /* Strings. borrowed: 1 = p is the input (a sink may record the
-     * offset), 0 = the decoder's scratch buffer (copy or take it). */
-    int (*str_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
-                   const char* tag, uint32_t tag_len);
-    int (*bytes_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
-                     const char* tag, uint32_t tag_len);
-    /* Containers. cap: expected item count (maps: pairs*2), UINT64_MAX
-     * for indefinite. close fires for BOTH the definite-complete and
-     * the break paths, after the last child. */
-    int (*open)(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len);
-    int (*close)(void* ctx, int is_map);
-} yep_cbor_sink;
+typedef yeptris_cbor_sax yep_cbor_sink;
 
 /* The generic engine: the grammar, driving `sink`. Same reject/
  * encoding/depth semantics as the DOM entry. */

data/vendor/libyeptris/src/yeptris/events/values.c

@@ -72,6 +72,16 @@ void yep_val_put(yep_value_ctx* c, const YeptrisValue* v) {
 void yep_val_slot(yep_value_ctx* c, YeptrisValue* v) {
     if (c->depth > 0 && c->depth <= YEP_V_MAX_DEPTH) {
         int di = c->depth - 1;
+        if (c->is_seq[di]) {
+            /* a sequence entry never takes a key slot — the toggle
+             * flagged every ODD-position entry is_key=1, and the
+             * marshal strict-dup scan then false-flagged arrays with a
+             * repeated value at two odd positions ("[\"a\",\"b\",\"a\"]"
+             * = "duplicate key in object"; yeptris-ruby#333, the
+             * yeptris#680 class resurfacing through the value
+             * stream's own parity) */
+            return;
+        }
         if (c->key_pend[di] == 0) {
             v->is_key = 1;
             c->key_pend[di] = 1;
@@ -169,6 +179,7 @@ static int transform(yep_value_ctx* c, const yep_rec_store* store) {
             yep_val_put(c, &v);
             if (c->depth < YEP_V_MAX_DEPTH) {
                 c->key_pend[c->depth] = 0;
+                c->is_seq[c->depth] = 1;
             }
             c->depth++;
             continue;
@@ -179,6 +190,7 @@ static int transform(yep_value_ctx* c, const yep_rec_store* store) {
             yep_val_put(c, &v);
             if (c->depth < YEP_V_MAX_DEPTH) {
                 c->key_pend[c->depth] = 0;
+                c->is_seq[c->depth] = 0;
             }
             c->depth++;
             continue;
@@ -285,6 +297,7 @@ static int lin_node(yep_value_ctx* c, const yep_dom* d, uint32_t id) {
     yep_val_put(c, &v);
     if (c->depth < YEP_V_MAX_DEPTH) {
         c->key_pend[c->depth] = 0;
+        c->is_seq[c->depth] = (n->kind == YEP_DOM_SEQUENCE);
     }
     c->depth++;
     if (lin_children(c, d, n) != 0) {

data/vendor/libyeptris/src/yeptris/events/values_priv.h

@@ -24,6 +24,8 @@ typedef struct yep_value_ctx {
     int oom;
     int unsupported;                   /* linearize: construct the emitter cannot express */
     uint8_t key_pend[YEP_V_MAX_DEPTH]; /* per open map: key slot taken */
+    uint8_t is_seq[YEP_V_MAX_DEPTH];   /* per open frame: 1 = sequence —
+                                        * entries never take key slots */
     int depth;
 } yep_value_ctx;
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.50.0
+  version: 0.6.51.0
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-29 00:00:00.000000000 Z
+date: 2026-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi