yeptris 0.6.11.1 → 0.6.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fab04bdd5f0236d59b5d139d410c095d9c99c8aacccaa18c464324c58b0eef33
-  data.tar.gz: 9ba0ca96dd534843e8238921f3de634c7f18b051f90b3bde901be74b950a6403
+  metadata.gz: 5900164f14038b2ef4e6c7b3e7764c335faf037559f9743099787e2ffcadb2f7
+  data.tar.gz: b539d2090254785c57c6dfd5a08e46200b668b0061619691e779a5c186a3978a
 SHA512:
-  metadata.gz: 2281939709069aaf555ed5df307cc613b304ad236d7c3fc13cca8a4fc28a0ee8ca35f41d7dd3b46c9db71a8a088d90565e4ccfd7aa25c4512a83d46b41bddd79
-  data.tar.gz: 9731da1240594c945e1eba4f7eef86e3ec10556c23ab0c84617b2109c17c2c08e08d2c64c5cd558103c07abe2ef93da00735ca6c42703e61fbae4eac7a0ad64c
+  metadata.gz: d837519cc77193279158957e4757a0b2ee6f250467d293422676135b6aee89058eac9dbb48c6b7a5f3eb79ca77cc1e076399f93935ed75d652612244b845db74
+  data.tar.gz: 5eff7ba15bd3c4314508d226ebaa4d2e3aa0eb0a7cc2887645078acbbecd193cbaa443af6877891b226224719b8955700f8567ec8a0446cc42fa713349993864

data/lib/yeptris/ffi.rb

@@ -28,6 +28,32 @@ module Yeptris
       MSG
     end
 
+    class << self
+      # #138's class, hit again by the oiml-cs report: a stale
+      # libyeptris on the machine (the Windows base-name dedupe makes
+      # a system copy win) lacks newer symbols, and a raising attach
+      # aborts this file mid-evaluation — every constant after it
+      # never defines, so the next autoload dies with
+      # 'uninitialized constant Yeptris::FFI::NODE_SCALAR'. Attaches
+      # now record the miss and define a raising stub of the same
+      # name: the load completes, optional surfaces fail with a clear
+      # message at USE, and the ESSENTIAL self-check at the bottom of
+      # this file raises the friendly load error for truly old
+      # engines.
+      def attach_function(name, args, ret, opts = {})
+        super
+      rescue ::FFI::NotFoundError, ::FFI::TypeError
+        define_singleton_method(name) do |*_a, **_kw|
+          raise ::FFI::NotFoundError,
+                "yeptris: #{name} is unavailable — the loaded " \
+                "libyeptris is older than this gem. Update the engine " \
+                "library (or clear the stale copy shadowing it)."
+        end
+        (@missing ||= []) << name
+        nil
+      end
+    end
+
 
     typedef :pointer, :yeptris_document
     typedef :pointer, :yeptris_node
@@ -194,18 +220,14 @@ module Yeptris
     # instead of walking per-value records in pure Ruby. Same feature-
     # detect discipline as the columnar drain (older libraries fall
     # back to the record walk).
-    MARSHAL = begin
-      MARSHAL_ALL_DOCS = 0
-      MARSHAL_FIRST_DOC = 1
-      attach_function :yeptris_marshal,
-                      %i[pointer size_t int int pointer pointer], :int
-      attach_function :yeptris_marshal_node,
-                      %i[yeptris_node pointer pointer], :int
-      attach_function :yeptris_marshal_free, [:pointer], :void
-      true
-    rescue ::FFI::NotFoundError
-      false
-    end
+    MARSHAL_ALL_DOCS = 0
+    MARSHAL_FIRST_DOC = 1
+    attach_function :yeptris_marshal,
+                    %i[pointer size_t int int pointer pointer], :int
+    attach_function :yeptris_marshal_node,
+                    %i[yeptris_node pointer pointer], :int
+    attach_function :yeptris_marshal_free, [:pointer], :void
+    MARSHAL = !(@missing ||= []).include?(:yeptris_marshal_node)
 
     # bulk build (TODO.impl/15 phase D): one call raises a document
     BUILD_SCALAR = 1
@@ -238,19 +260,15 @@ module Yeptris
 
     # CBOR (RFC 8949, TODO.cbor): absent on libraries before the
     # codec's release — the CBOR module feature-detects
-    CBOR_EX = begin
-      attach_function :yeptris_cbor_decode, %i[pointer size_t uint32 yeptris_status_out],
-                      :yeptris_document
-      callback :cbor_item_cb, %i[pointer yeptris_document size_t], :int
-      attach_function :yeptris_cbor_decode_sequence,
-                      %i[pointer size_t uint32 cbor_item_cb pointer yeptris_status_out], :size_t
-      attach_function :yeptris_cbor_encode, %i[yeptris_document uint32 pointer], :pointer
-      attach_function :yeptris_cbor_encode_sequence,
-                      %i[pointer size_t uint32 pointer], :pointer
-      true
-    rescue ::FFI::NotFoundError
-      false
-    end
+    attach_function :yeptris_cbor_decode, %i[pointer size_t uint32 yeptris_status_out],
+                    :yeptris_document
+    callback :cbor_item_cb, %i[pointer yeptris_document size_t], :int
+    attach_function :yeptris_cbor_decode_sequence,
+                    %i[pointer size_t uint32 cbor_item_cb pointer yeptris_status_out], :size_t
+    attach_function :yeptris_cbor_encode, %i[yeptris_document uint32 pointer], :pointer
+    attach_function :yeptris_cbor_encode_sequence,
+                    %i[pointer size_t uint32 pointer], :pointer
+    CBOR_EX = !(@missing ||= []).include?(:yeptris_cbor_decode)
 
     # Owned char* results (serialize*): one reader, freed exactly once.
     # The release goes through yeptris_free (libyeptris's own
@@ -337,6 +355,7 @@ module Yeptris
     TAG_BOOL = 3
     TAG_NULL = 4
     TAG_TIMESTAMP = 5
+    TAG_BINARY = 8
 
     # the schema-descriptor API (issue #238; TODO.restructure/83)
     DESC_ABI = 1
@@ -367,5 +386,24 @@ module Yeptris
     ERROR_ARG = 6
     ERROR_UNSUPPORTED = 7
     ERROR_INTERNAL = 8
+    # The load-time essentials (the read path + the ownership
+    # contract): absent on engines far older than the optional
+    # surfaces — raise the friendly error once every constant has
+    # fully defined, so no partial-module state leaks into autoloads
+    # (the #138 class, closed at the root).
+    ESSENTIAL = %i[
+      yeptris_version yeptris_last_error yeptris_parse yeptris_parse_ex
+      yeptris_parse_json yeptris_document_free yeptris_document_count
+      yeptris_document_root yeptris_node_kind yeptris_node_value
+      yeptris_node_tag_id yeptris_node_style yeptris_document_new
+      yeptris_document_set_root yeptris_serialize yeptris_serialize_ex
+    ].freeze
+    missing_core = ESSENTIAL & (@missing ||= [])
+    raise ::FFI::NotFoundError,
+          "yeptris: the loaded libyeptris is older than this gem " \
+          "requires (missing: #{missing_core.join(', ')}). Update the " \
+          "engine library, or clear the stale copy shadowing it." \
+          unless missing_core.empty?
+
   end
 end

data/lib/yeptris/materializer.rb

@@ -37,6 +37,7 @@ module Yeptris
     TAG_BOOL = Yeptris::FFI::TAG_BOOL
     TAG_NULL = Yeptris::FFI::TAG_NULL
     TAG_TIMESTAMP = Yeptris::FFI::TAG_TIMESTAMP
+  TAG_BINARY = Yeptris::FFI::TAG_BINARY
     TAG_MERGE = 9 # YEPTRIS_TAG_MERGE (resolve.h): a plain '<<' key
 
     INF_WORDS = {
@@ -152,6 +153,8 @@ module Yeptris
           float_or_string(value)
         when TAG_TIMESTAMP
           parse_timestamp(value)
+        when TAG_BINARY
+          value.unpack1("m") # psych to_ruby: !binary -> decode64, ASCII-8BIT (#168)
         else
           value
         end

data/lib/yeptris/node.rb

@@ -121,6 +121,7 @@ class Yeptris::Node
     Yeptris::FFI::TAG_BOOL => :bool,
     Yeptris::FFI::TAG_NULL => :null,
     Yeptris::FFI::TAG_TIMESTAMP => :timestamp,
+    Yeptris::FFI::TAG_BINARY => :binary,
   }.freeze
 
   def tag_id
@@ -351,6 +352,7 @@ class Yeptris::Node
         to_f
       end
     when :timestamp then ::Yeptris::Materializer.parse_timestamp(value)
+    when :binary then value.unpack1("m") # ASCII-8BIT bytes (#168)
     else
       # beyond int64 the C resolver leaves plain scalars :str; Psych
       # materializes Integer (issue #31) — rebuild from the text

data/lib/yeptris/psych/drop_in.rb

@@ -22,6 +22,27 @@ end
 Object.class_eval { remove_const(:Psych) } if defined?(::Psych) && !::Psych.equal?(Yeptris::Psych)
 ::Psych = Yeptris::Psych
 
+# #167: third-party gems feature-gate on Psych::VERSION at require
+# time (mechanize 2.14.1's cookie-jar reads it in a class body). The
+# face reports the STDLIB version it replaces: ORIGINAL's when psych
+# was preloaded, else the default-gem spec's version (local lookup —
+# requiring stdlib psych post-rebind is censored by the header).
+unless Yeptris::Psych.const_defined?(:VERSION, false)
+  version =
+    if Yeptris::Psych.const_defined?(:ORIGINAL, false)
+      Yeptris::Psych::ORIGINAL::VERSION
+    else
+      spec = begin
+        ::Gem.loaded_specs["psych"] ||
+          ::Gem::Specification.find_by_name("psych", ::Gem::Requirement.default)
+      rescue ::StandardError, ::Gem::Exception, ::LoadError
+        nil
+      end
+      spec&.version&.to_s
+    end
+  Yeptris::Psych.const_set(:VERSION, version) if version
+end
+
 # yaml-first boot order: ::YAML still references the ORIGINAL stdlib
 # module object, whose singleton methods route through stdlib's parse
 # stream — the UTF-8 tagging (and every other normalization) never

data/lib/yeptris/psych.rb

@@ -165,7 +165,18 @@ module Yeptris
       def force_utf8_scalars(obj)
         case obj
         when ::String
-          obj.force_encoding(::Encoding::UTF_8) if obj.encoding == ::Encoding::ASCII_8BIT && !obj.ascii_only?
+          # valid_encoding? on an ASCII-8BIT string is ALWAYS true
+          # (it is bytes) — the discriminator is whether the bytes
+          # READ as UTF-8: #135's case (UTF-8 scalars the C side
+          # materialized as BINARY) re-tags; DECODED !binary bytes
+          # that are not UTF-8 stay BINARY (#168). Binary content that
+          # happens to be valid UTF-8 re-tags — noted divergence from
+          # stdlib, which keeps BINARY; real payloads (zips, bodies)
+          # never are.
+          if obj.encoding == ::Encoding::ASCII_8BIT && !obj.ascii_only?
+            probe = obj.dup.force_encoding(::Encoding::UTF_8)
+            obj.force_encoding(::Encoding::UTF_8) if probe.valid_encoding?
+          end
           obj
         when ::Hash
           obj.each { |k, v| force_utf8_scalars(k); force_utf8_scalars(v) }
@@ -307,7 +318,9 @@ module Yeptris
         when :scalar, :mapping, :sequence
           tag = node.tag
           unless tag.nil?
-            name = tag.split(":").last
+            # both tag spellings pass: the URI form's last segment and
+            # the short "!binary" shorthand (#168's cassettes carry it)
+            name = tag.split(":").last.sub(/\A!/, "")
             unless %w[str int float bool null timestamp seq map merge value
                       binary].include?(name)
               raise DisallowedClass, name

data/lib/yeptris/yaml.rb

@@ -192,7 +192,19 @@ module Yeptris
             obj.each { |e| place(e, emit, blob, off, seen) }
             emit.call(STOP, 0, 0, 0)
           end
-        when String then scalar(obj, STYLE_BY_NAME[string_style(obj)], emit, blob, off)
+        when String
+          if obj.encoding == ::Encoding::ASCII_8BIT && !obj.ascii_only?
+            # #168: psych visit_String's binary branch — strict base64
+            # + the short !binary tag + literal style (Builder
+            # build_string carries the same branch; the tagged-literal
+            # writer keeps the block form)
+            scalar([obj].pack("m0"), STYLE_LIT, emit, blob, off)
+            emit.call(BUILD_TAG, 0, off[0], 7)
+            blob << "!binary"
+            off[0] += 7
+          else
+            scalar(obj, STYLE_BY_NAME[string_style(obj)], emit, blob, off)
+          end
         when Symbol then scalar(":#{obj}", STYLE_PLAIN, emit, blob, off)
         when Integer then scalar(obj.to_s, STYLE_PLAIN, emit, blob, off)
         when Float then scalar(float_text(obj), STYLE_PLAIN, emit, blob, off)
@@ -351,6 +363,17 @@ module Yeptris
       # visit_String matrix) serves both builders; this side carries
       # the style onto the per-node DOM.
       def build_string(doc, s)
+        # psych 5.5 visit_String's binary branch, verbatim: an
+        # ASCII-8BIT string with non-ASCII bytes emits as strict base64
+        # (pack('m0'), never wrapped) under the short !binary tag with
+        # literal style — the writer keeps the block form for tagged
+        # literals (#168). BOTH dump paths converge here (the top-level
+        # scalar fast route and the YAMLTree visitor).
+        if s.encoding == ::Encoding::ASCII_8BIT && !s.ascii_only?
+          bin = new_scalar(doc, [s].pack("m0"), :force_lit)
+          bin.set_tag("!binary")
+          return bin
+        end
         case BulkBuilder.string_style(s)
         when :single then new_scalar(doc, s, :force_str_sq)
         when :double then new_scalar(doc, s, :force_str)

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.11.1".freeze
+  VERSION = "0.6.12.3".freeze
   # The error hierarchy lives in THIS file (the parent namespace's
   # own file): nested constants do not trigger a parent-constant
   # autoload, and the law forbids internal requires — defining the

data/vendor/libyeptris/CMakeLists.txt

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

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

@@ -221,12 +221,16 @@ YEPTRIS_API YeptrisStatus yeptris_document_build(YeptrisDocument handle,
     int depth = 0;
     uint32_t root = UINT32_MAX;
     uint32_t root_closed = 0;
+    uint32_t root_tagged = 0;          /* one trailing TAG on the closed root (#168) */
     uint32_t pending_key = UINT32_MAX; /* map frame's buffered key */
     uint32_t last_id = UINT32_MAX;     /* TAG applies here (#300) */
     YeptrisStatus rc = YEPTRIS_OK;
     for (size_t i = 0; i < count && rc == YEPTRIS_OK; i++) {
         const YeptrisBuildEntry* e = &entries[i];
-        if (root_closed) {
+        /* A closed SCALAR root admits exactly one trailing TAG —
+         * psych's binary root is `--- !binary |-` (#168); everything
+         * after (more ops, a second tag) still rejects */
+        if (root_closed && !(e->op == YEPTRIS_BUILD_TAG && !root_tagged && last_id == root)) {
             rc = YEPTRIS_ERROR_PARSE; /* the document ended; more entries */
             break;
         }
@@ -283,6 +287,7 @@ YEPTRIS_API YeptrisStatus yeptris_document_build(YeptrisDocument handle,
                 rc = YEPTRIS_ERROR_MEMORY;
                 break;
             }
+            root_tagged = root_closed;
             continue;
         default:
             rc = YEPTRIS_ERROR_PARSE; /* unknown op */

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

@@ -480,17 +480,11 @@ yep_dom* yep_dom_create(const yep_allocator* sys) {
     memset(d, 0, sizeof(*d));
     d->sys = sys;
     d->pool = pool;
-    d->handles = yep_hpool_create(sys);
-    if (d->handles == NULL) {
-        yep_pool_destroy(pool);
-        yep_free(sys, d);
-        return NULL;
-    }
+    /* #157: the handle pool is lazy — two allocations and a mutex per
+     * document that decode-only consumers (CBOR load, serialize, free)
+     * never touch; yep_dom_handles() materializes it on first use */
+    d->handles = NULL;
     if (yep_mutex_init(&d->midx.mu) != 0) {
-        yep_free(d->sys, d->anchor_nodes);
-        yep_free(d->sys, d->mut_att);
-        yep_free(d->sys, d->mut_depth);
-        yep_hpool_destroy(d->handles);
         yep_pool_destroy(pool);
         yep_free(sys, d);
         return NULL;
@@ -499,6 +493,25 @@ yep_dom* yep_dom_create(const yep_allocator* sys) {
     return d;
 }
 
+/* Lazy handle pool, mirroring the map-index's discipline (mapindex.c):
+ * EVERY access rides the dom's lazy-init mutex — read-only sharing
+ * means multiple threads may race the FIRST handle creation on a
+ * shared document (Threads.ReadOnlySharing; the TSAN catch on the
+ * first cut). The uncontended lock costs less than the hpool's own
+ * per-allocation lock that follows. */
+struct yep_hpool* yep_dom_handles(yep_dom* d) {
+    if (d == NULL || !d->midx.mu_ready) {
+        return NULL;
+    }
+    yep_mutex_lock(&d->midx.mu);
+    if (d->handles == NULL) {
+        d->handles = yep_hpool_create(d->sys);
+    }
+    struct yep_hpool* h = d->handles;
+    yep_mutex_unlock(&d->midx.mu);
+    return h;
+}
+
 void yep_dom_destroy(yep_dom* d) {
     if (d == NULL) {
         return;

data/vendor/libyeptris/src/yeptris/dom/dom.h

@@ -197,6 +197,8 @@ void dom_mut_set_depth(yep_dom* d, uint32_t id, uint16_t depth);
 
 /* thread-safe handle arena (see hpool.c) */
 struct yep_hpool* yep_hpool_create(const yep_allocator* sys);
+/* Lazy handle-pool acquisition (#157): NULL dom or OOM stays NULL. */
+struct yep_hpool* yep_dom_handles(yep_dom* d);
 void yep_hpool_destroy(struct yep_hpool* p);
 void* yep_hpool_alloc(struct yep_hpool* p, size_t size, size_t align);
 

data/vendor/libyeptris/src/yeptris/emit/writer.c

@@ -313,7 +313,8 @@ static void emit_canonical_scalar(yep_writer* w, const yep_dnode* n) {
 enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL };
 #define YEP_SC_MEMO_MIN 32u /* bytes; derive-below, memoize-above */
 
-static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in) {
+static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in,
+                        int has_tag) {
     int multiline = (len > 0 && memchr(p, '\n', len) != NULL);
     int blockable = 0;
     if (multiline && !as_key) {
@@ -343,6 +344,13 @@ static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key,
         if (len == 0) {
             return YEP_SC_DQ;
         }
+        /* A TAGGED block scalar keeps the block form even single-line
+         * (psych's !binary emits `!binary |-` + one base64 line; an
+         * untagged single-line literal re-emits plain — libyaml parity,
+         * the #290 family) */
+        if (has_tag) {
+            return YEP_SC_LITERAL;
+        }
         sty = 1;
     }
     switch (sty) {
@@ -388,14 +396,14 @@ static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int a
      * memoized long scalars, in visit order either way. */
     if (w->sc_dec != NULL && len >= YEP_SC_MEMO_MIN) {
         if (w->dry) {
-            route = sc_route(w, p, len, as_key, n->style);
+            route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0);
             w->sc_dec[w->sc_i] = route;
         } else {
             route = w->sc_dec[w->sc_i];
         }
         w->sc_i++;
     } else {
-        route = sc_route(w, p, len, as_key, n->style);
+        route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0);
     }
     switch (route) {
     case YEP_SC_NOTHING:

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

@@ -40,6 +40,7 @@
 
 #include <yeptris/error.h>
 #include <yeptris/marshal.h>
+#include <yeptris/resolve.h> /* YEPTRIS_TAG_BINARY (#168) */
 
 typedef struct {
     const char* name; /* into the value arena */
@@ -487,6 +488,9 @@ static int pre_scan(const yep_value_ctx* c, uint64_t** counts_out, size_t* nopen
         case YEP_V_TIMESTAMP:
             return -2;
         case YEP_V_STR:
+            if (vals[i].tag_id == YEPTRIS_TAG_BINARY) {
+                return -2; /* !binary: the walk base64-decodes (#168) */
+            }
             if (vals[i].is_key == 1 && vals[i].len == 2 && c->arena[vals[i].off] == '<' &&
                 c->arena[vals[i].off + 1] == '<') {
                 return -2; /* merge key: the walk resolves these */

data/vendor/libyeptris/src/yeptris/memory/pool.c

@@ -45,6 +45,15 @@ void* yep_pool_alloc(yep_pool* pool, size_t size, size_t align) {
     }
 
     yep_block* b = pool->head;
+    if (b == NULL) { /* the lazy first block (#157) */
+        b = yep_block_new(pool->sys, pool->block_size);
+        if (b == NULL) {
+            return NULL;
+        }
+        b->next = NULL;
+        pool->head = b;
+        pool->blocks = 1;
+    }
     uintptr_t base = (uintptr_t)b + sizeof(yep_block);
     uintptr_t start = yep_round_up(base + b->used, align);
 
@@ -88,12 +97,10 @@ yep_pool* yep_pool_create(const yep_allocator* sys, size_t block_size) {
     }
     p->sys = sys;
     p->block_size = block_size;
-    p->head = yep_block_new(sys, block_size);
-    p->blocks = 1;
-    if (p->head == NULL) {
-        yep_free(sys, p);
-        return NULL;
-    }
+    /* #157: the first block is lazy — one fewer eager allocation per
+     * document; pool_alloc materializes it on first use */
+    p->head = NULL;
+    p->blocks = 0;
     return p;
 }
 

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

@@ -27,6 +27,7 @@
 #include "resolve/resolver.h"
 #include "scan/json.h"
 #include "scan/scan.h"
+#include <yeptris/resolve.h> /* YEPTRIS_TAG_* names (#168) */
 
 #define YEP_MAX_DEPTH 1000
 #define YEP_MAX_FOLD_LINES 8192
@@ -158,7 +159,15 @@ static int emit_now(yep_engine* e, const yep_event* ev) {
         /* Resolution happens exactly here: every scalar path flows
          * through this choke point (the resolver is the typing SSOT) */
         if (ev->tag.len > 0) {
-            ((yep_event*)ev)->tag_id = yep_tag_from_uri((const char*)ev->tag.p, ev->tag.len);
+            yep_tag_id tid = yep_tag_from_uri((const char*)ev->tag.p, ev->tag.len);
+            /* psych's own dumped form is the LOCAL !binary shorthand,
+             * and stdlib to_ruby accepts it beside the core URI (#168)
+             * — compat schemas resolve it to BINARY as well */
+            if (tid == YEPTRIS_TAG_CUSTOM && ev->tag.len == 7 &&
+                memcmp(ev->tag.p, "!binary", 7) == 0 && e->resolver == yep_resolver_compat11()) {
+                tid = YEPTRIS_TAG_BINARY;
+            }
+            ((yep_event*)ev)->tag_id = tid;
         } else if (ev->implicit && e->resolver != NULL) {
             ((yep_event*)ev)->tag_id = e->resolver->resolve(
                 e->resolver->ctx, (const char*)ev->value.p, (uint32_t)ev->value.len);

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

@@ -375,7 +375,7 @@ YEPTRIS_API size_t yeptris_document_count(YeptrisDocument handle) {
 }
 
 yeptris_node* yep_handle_new(yeptris_document* doc, uint32_t id) {
-    yeptris_node* n = yep_hpool_alloc(doc->dom->handles, sizeof(yeptris_node), 16);
+    yeptris_node* n = yep_hpool_alloc(yep_dom_handles(doc->dom), sizeof(yeptris_node), 16);
     if (n == NULL) {
         return NULL;
     }
@@ -552,7 +552,7 @@ static YeptrisNode wrap(yeptris_node* base, uint32_t id) {
     /* Handles live in the document's thread-safe arena: one
      * document_free reclaims every handle ever handed out (zero-leak
      * contract) while read-only sharing stays safe (TODO.impl/19) */
-    yeptris_node* n = yep_hpool_alloc(base->doc->dom->handles, sizeof(yeptris_node), 16);
+    yeptris_node* n = yep_hpool_alloc(yep_dom_handles(base->doc->dom), sizeof(yeptris_node), 16);
     if (n == NULL) {
         return NULL;
     }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.11.1
+  version: 0.6.12.3
 platform: ruby
 authors:
 - Ribose Inc.