yeptris 0.6.23.1-arm-linux-eabihf → 0.6.26.1-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 627e70bedb0bd290674f8a94d08ad53c68e48cf60b5752783b6d8db3391921d3
-  data.tar.gz: 79403cdb0ce605fd4d79777291e02274afb041200f9f5b7d8972538442a29a31
+  metadata.gz: e47e094203051044900e0b675f67289e3b86c751c0ad2762751f57fae9f21f65
+  data.tar.gz: ae6b25e84793e88d8d86698df20fc17e3fd5ad19d8a52f79e7b44c36ff5a358a
 SHA512:
-  metadata.gz: 1512bd1736078082f3de2a1c07afc42c998ba53a5204fb2073a8c3f49510231c42deb96322cf92ac16764df6c24eeaa7b02fad5cfc0113bdefbd97beb039355a
-  data.tar.gz: 44c9e72d06b689ce1e18e4b2283421f99d20ee9b89a076a1e0439d91d0b0254cae04a819334c6b63a3ba49d686efe57eef39871dce52f36a36cfb5301c67fbf1
+  metadata.gz: eec0297f6dd573f5d9fd3bc1ad4bc78d553197b7b9c7129b2bf8259d47feebe72c8f2a3b130926412cbb38130fb881dba4c46695597c1f19768320b6e6287354
+  data.tar.gz: 800c7a3984dc1ffac1c7d61be602f6d3890ccdf595601c220bf26a66bf6b931eaccfabfa4fa030454a0ecaeb23bf7549ca4ea7c77458d824759f76a0e222b95b

data/lib/yeptris/document.rb

@@ -17,6 +17,16 @@ class Yeptris::Document
   attr_reader :parse_schema
 
   def initialize(c_ptr = nil, freed = Freed.new(:alive), parse_schema = :core_12)
+    # The pointer is produced by the FFI parse/create calls; a nil (or
+    # non-pointer) argument is an API misuse — Document.parse and
+    # Document.create are the entry points. Fail with that guidance
+    # instead of a NoMethodError from the finalizer guard below (the
+    # FFI::Pointer#null? probe does not exist on nil).
+    unless c_ptr.is_a?(::FFI::Pointer)
+      raise ArgumentError,
+            "a document FFI pointer is required — build documents with " \
+            "Yeptris::Document.parse or Yeptris::Document.create"
+    end
     @c_ptr = c_ptr
     @freed = freed
     @parse_schema = parse_schema

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.23.1".freeze
+  VERSION = "0.6.26.1".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.23
+    VERSION 0.6.26
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

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

@@ -52,6 +52,12 @@ YEPTRIS_API YeptrisStatus yeptris_recorder_feed(YeptrisRecorder rec, const char*
         }
         yep_engine_set_resolver(rec->eng,
                                 rec->compat11 ? yep_resolver_compat11() : yep_resolver_core12());
+        /* the compat schema is the psych/libyaml surface: its grammar
+         * must accept what libyaml accepts (the flow indent floor is
+         * suite-strict, not libyaml — see yep_engine_set_compat_grammar;
+         * the recorder is the py safe_load path, which rode the floor
+         * and rejected multi-line flows #431 fixed everywhere else) */
+        yep_engine_set_compat_grammar(rec->eng, rec->compat11);
     }
     if (final) {
         rec->final_fed = 1;

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

@@ -389,6 +389,11 @@ int yep_values_from_input(const char* yaml, size_t len, int schema_compat, yep_v
         return -1;
     }
     yep_engine_set_resolver(eng, schema_compat ? yep_resolver_compat11() : yep_resolver_core12());
+    if (schema_compat) {
+        yep_engine_set_compat_grammar(eng, 1); /* libyaml grammar parity
+                                                * (the value drains ride the
+                                                * same compat contract) */
+    }
 
     yep_value_ctx* c = ctx_create();
     if (c == NULL) {

data/vendor/libyeptris/src/yeptris/parse/engine.c

@@ -124,6 +124,13 @@ struct yep_engine {
     int doc_inline;                      /* content node opened on the --- line */
     uint16_t flow_floor;                 /* parent column of the current block-level flow */
     int flow_enforce;                    /* flow continuation lines must out-indent it */
+    int compat_grammar;                  /* 11-COMPAT: libyaml/psych grammar parity —
+                                          * the flow indent floor (9C9N/VJP3) is a
+                                          * yaml-test-suite rule libyaml never
+                                          * enforced, and real-world locale files
+                                          * close multi-line flows at the parent's
+                                          * column; the floor stays on for the
+                                          * strict 1.2 engine the suite runs */
 };
 
 /* ------------------------------------------------------------ forwards */
@@ -2308,7 +2315,7 @@ static int e_shape_flow_value(yep_engine* e, const yep_line_shape* sh, uint16_t
     yep_view none = {NULL, 0};
     e->pos = sh->val_start;
     e->flow_floor = floor;
-    e->flow_enforce = (e->depth > 0);
+    e->flow_enforce = (e->depth > 0) && !e->compat_grammar;
     int fast = e_flow_json(e, none, none, 0);
     e->flow_enforce = 0;
     if (fast == -2) {
@@ -2735,7 +2742,7 @@ static int e_node(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
             /* JSON fast path first: its validating scan already finds the
              * close, replacing e_skip_flow's pre-scan when it applies. */
             e->flow_floor = floor_col;
-            e->flow_enforce = (e->depth > 0);
+            e->flow_enforce = (e->depth > 0) && !e->compat_grammar;
             int fast = e_flow_json(e, node_a, node_t, anchor_ordinal);
             e->flow_enforce = 0;
             if (fast == 1) {
@@ -2780,7 +2787,7 @@ static int e_node(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
         }
         {
             e->flow_floor = floor_col;
-            e->flow_enforce = (e->depth > 0);
+            e->flow_enforce = (e->depth > 0) && !e->compat_grammar;
             int rc = e_flow(e, node_a, node_t, node_aid);
             e->flow_enforce = 0;
             if (rc != 0) {
@@ -3112,6 +3119,12 @@ void yep_engine_set_resolver(yep_engine* e, const yep_resolver* r) {
     }
 }
 
+void yep_engine_set_compat_grammar(yep_engine* e, int on) {
+    if (e != NULL) {
+        e->compat_grammar = on != 0;
+    }
+}
+
 void yep_engine_set_max_depth(yep_engine* e, int depth) {
     if (e != NULL && depth > 0) {
         e->max_depth = depth > YEP_MAX_DEPTH ? YEP_MAX_DEPTH : depth;
@@ -3166,10 +3179,46 @@ yep_engine* yep_engine_create(const yep_allocator* sys) {
  * input is copied with each normalized to a single '\n' (libyaml reader
  * behavior); inputs without them keep the zero-copy path. */
 static const char* e_normalize_breaks(yep_engine* e, const char* p, size_t len) {
+    char* out = yep_engine_normalize_breaks(e->sys, p, len, NULL);
+    if (out == NULL) {
+        return p;
+    }
+    e->norm_buf = out;
+    return out;
+}
+
+/* The NEL/LS/PS -> '\n' copy (the one-shot path rides this BEFORE the
+ * engine so the normalized bytes own the document's `transcoded` slot;
+ * the engine's per-feed copy stays for the streaming feeds). Returns
+ * NULL when the input has no exotic break. */
+/* The two possible LEAD bytes of a Unicode break (NEL = C2 85; LS/PS =
+ * E2 80 A8/A9). The whole-document probe rides the SIMD stopset kernel
+ * and only candidates get the byte check — the per-byte walk was 11%
+ * of every parse (exclusive profile, block-heavy DOM, 2026-09-27).
+ * Pinned against yep_stopset_init by Parse.NormBreakLeadsMatchRuntimeBuild. */
+const yep_stopset yep_norm_break_leads = {
+    .bitmap = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+               0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00},
+    .groups = 1,
+    .lo = {{0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00}},
+    .hi = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+            0x02, 0x00}},
+};
+
+char* yep_engine_normalize_breaks(const yep_allocator* sys, const char* p, size_t len,
+                                  size_t* out_len) {
     const unsigned char* q = (const unsigned char*)p;
+    const yep_text_kernels* k = yep_text_active();
     size_t i = 0;
     int found = 0;
     while (i < len) {
+        ptrdiff_t hit = k->stopset_find(&yep_norm_break_leads, (const char*)q + i, len - i);
+        if (hit < 0) {
+            break;
+        }
+        i += (size_t)hit;
         if (q[i] == 0xC2 && i + 1 < len && q[i + 1] == 0x85) {
             found = 1;
             break;
@@ -3182,11 +3231,11 @@ static const char* e_normalize_breaks(yep_engine* e, const char* p, size_t len)
         i++;
     }
     if (!found) {
-        return p;
+        return NULL;
     }
-    char* out = yep_alloc(e->sys, len + 1);
+    char* out = yep_alloc(sys, len + 1);
     if (out == NULL) {
-        return p; /* fall back: parse as-is */
+        return NULL;
     }
     size_t o = 0;
     for (size_t j = 0; j < len;) {
@@ -3202,7 +3251,9 @@ static const char* e_normalize_breaks(yep_engine* e, const char* p, size_t len)
         }
     }
     out[o] = '\0';
-    e->norm_buf = out;
+    if (out_len != NULL) {
+        *out_len = o;
+    }
     return out;
 }
 

data/vendor/libyeptris/src/yeptris/parse/engine.h

@@ -11,6 +11,7 @@
 
 #include "common/error.h"
 #include "common/simd_text.h"
+
 #include "memory/allocator.h"
 #include "memory/pool.h"
 #include "parse/events.h"
@@ -19,6 +20,9 @@
 extern "C" {
 #endif
 
+/* Pinned by Parse.NormBreakLeadsMatchRuntimeBuild (test_parse.cpp). */
+extern const yep_stopset yep_norm_break_leads;
+
 typedef struct yep_engine yep_engine;
 
 yep_engine* yep_engine_create(const yep_allocator* sys);
@@ -52,12 +56,26 @@ struct yep_resolver;
 void yep_engine_set_resolver(yep_engine* e, const struct yep_resolver* r);
 void yep_engine_set_max_depth(yep_engine* e, int depth);
 
+/* The 1.1-compat grammar (libyaml/psych parity): the block-level flow
+ * indent floor (9C9N, VJP3) is a yaml-test-suite rule libyaml never
+ * enforced — real-world locale files close multi-line flow collections
+ * at their parent's column ("k: {\n  a: b\n}"). Off by default (the
+ * strict 1.2 engine the conformance suite runs keeps the floor). */
+void yep_engine_set_compat_grammar(yep_engine* e, int on);
+
 /* Byte offset the last run reached (into that run's buffer); used by
  * consumers that stop the engine at a boundary and resume. */
 size_t yep_engine_pos(const yep_engine* e);
 
 const yep_error* yep_engine_error(const yep_engine* e);
 
+/* The NEL/LS/PS -> '\n' copy; NULL when the input is clean (probe rides
+ * the stopset kernel). One-shot parse runs this BEFORE the engine so
+ * the copy owns the document's transcoded slot; the engine's per-feed
+ * copy (norm_buf) stays for the streaming feeds. */
+char* yep_engine_normalize_breaks(const yep_allocator* sys, const char* p, size_t len,
+                                  size_t* out_len);
+
 #ifdef __cplusplus
 }
 #endif

data/vendor/libyeptris/src/yeptris/parse.c

@@ -293,6 +293,26 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
         }
     }
 
+    /* Unicode breaks (NEL/LS/PS) normalize to '\n' BEFORE the engine:
+     * the copy rides `transcoded`, whose ownership plumbing (input_base
+     * views, doc free, fail paths) already exists. Letting the engine's
+     * per-feed copy fire here returned views into ENGINE-owned memory
+     * that dies at yeptris_parse teardown — every one-shot NEL document
+     * dangled (no test ever covered one; found by the NormBreakLeads
+     * slice, 2026-09-27). JSON mode skips this: the JSON reader keeps
+     * U+0085 raw inside strings, only the YAML reader normalizes. */
+    {
+        size_t nlen = 0;
+        char* norm = yep_engine_normalize_breaks(sys, data, data_len, &nlen);
+        if (norm != NULL) {
+            yep_free(sys, transcoded);
+            transcoded = (unsigned char*)norm;
+            transcoded_len = nlen;
+            data = norm;
+            data_len = nlen;
+        }
+    }
+
     /* Engine → DOM. */
     yep_engine* eng = NULL;
 engine_enter:
@@ -301,6 +321,12 @@ engine_enter:
         yep_engine_set_resolver(eng, opts->schema == YEPTRIS_SCHEMA_11_COMPAT
                                          ? yep_resolver_compat11()
                                          : yep_resolver_core12());
+        if (opts->schema == YEPTRIS_SCHEMA_11_COMPAT) {
+            /* the compat schema is the psych/libyaml surface: its grammar
+             * must accept what libyaml accepts (the flow floor is suite-
+             * strict, not libyaml — see yep_engine_set_compat_grammar) */
+            yep_engine_set_compat_grammar(eng, 1);
+        }
         if (opts->max_depth > 0) {
             yep_engine_set_max_depth(eng, opts->max_depth);
         }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.23.1
+  version: 0.6.26.1
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.