yeptris 0.1.10.0 → 0.1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cec65c1f8da9f6256a42fdf00f6c03c637376c0a0e4d0305f4b540f31f43cc1e
-  data.tar.gz: fb4d51fe7dad0b08c1364b32572b4abd92fa737fab79066665c9ce0820f3c6b9
+  metadata.gz: b2ddefc4cfb21c80a7238bbca6cfa46293fd0f3ff920a122e37bd6f4e3f78b0e
+  data.tar.gz: cfbfe8da20325e11ef811dd9372e464fd1e03a1c0eff21cae254f918c9f5c979
 SHA512:
-  metadata.gz: 2c361ed6318a55ebdaeaacc56130e5972d699e065dcb7ed0453e84660f9c8f7054d7db1b55ab382bf438484b5a3cb42c201711517cd4feee7d08a90fd0b2fc17
-  data.tar.gz: 9553bc1afea94e8188dd8d28d8b7186c697865cfc5757fb1e42ab1fc6196fe83ba9a5834af922e65acd5ddca861c0f6b6dddfeec9d14fc2eecc8f19aa46559fe
+  metadata.gz: 76f113166f28712bb328a7daf7f5b15f37f06c4ca5ce24dc56651878bded33800e3befbefed6b66f4da0a28a94c595797fb41004572d807a5ebca93a342e1cc6
+  data.tar.gz: 273c6e45ff73043c14c24869b3d98207710514dcd055a939d0fa4c5832d133bf5d14686ba9259c712115b4034cb5785c9af6aaa9bbabf929315dd43c313cf997

data/README.adoc

@@ -7,8 +7,9 @@ compilation at install.
 
 == Install (development)
 
-The native library is vendored in the platform gems (TODO.impl/15
-phase D). For development against a local build:
+The gem loads a shared `libyeptris` — from `YEPTRIS_LIB_PATH`, a
+vendored `lib/platform/<tag>/` copy, or the system paths. For
+development against a local build:
 
 ....
 # the sibling C checkout: ~/src/leptris/yeptris
@@ -32,7 +33,9 @@ require "yeptris"
 Yeptris::YAML.load("name: yeptris\nrating: 10\n")
 # => {"name" => "yeptris", "rating" => 10}
 
-Yeptris::YAML.dump("name" => "yeptris", tags: [:yaml, :fast])
+# brace mixed hashes on Ruby 3.x: a trailing symbol key otherwise
+# splits the literal into keywords
+Yeptris::YAML.dump({"name" => "yeptris", "tags" => [:yaml, :fast]})
 
 doc = Yeptris::Document.parse(config_yaml)
 doc.root["server"]["port"].to_i
@@ -49,11 +52,21 @@ Handles are document-scoped: `Document#free` releases everything
 (one C call), a GC finalizer backs it up, and any use after free
 raises `Yeptris::FreedError` — never a segfault.
 
-== Roadmap
+== Shipped beyond the original plan
 
-* Phase B: recorder-driven Ruby materialization (bulk event records,
-  the FFI tax paid per chunk, not per node) + the `Yeptris::Psych`
-  drop-in namespace and the ported Psych suite.
-* Phase C: `.tml` corpora, readonly mode, YAMLTree dumps.
-* Phase D: vendored precompiled platform gems, lockstep versioning
-  with the C library, symbol audit task.
+* The columnar value drain (bulk, pre-converted typed columns — the
+  load fast path) and the bulk DOM builder (one `document_build`
+  call per dump).
+* **Ruby Marshal 4.8 emission** (libyeptris >= 0.1.11): the C side
+  converts value records into Marshal bytes; one `Marshal.load`
+  materializes the whole graph. ~10× faster than the columnar walk
+  on JSON-shaped input, ~5× on YAML, ~50× on the per-node DOM walk
+  (`Node#to_ruby` becomes bulk). Alias identity preserved through
+  object links; merge keys and timestamps return UNSUPPORTED for the
+  record-walk fallback.
+* `Yeptris::Psych` — the drop-in namespace with the ported Psych
+  suite (143 specs), `.tml` corpora conformance, and the object
+  visitor (`encode_with`/`init_with`).
+* Lockstep versioning with the C library
+  (`{c-semver}.{gem-patch}`); releases published from the C repo's
+  workflow through the RubyGems trusted publisher.

data/lib/yeptris/ffi.rb

@@ -136,6 +136,25 @@ module Yeptris
              :bools, :pointer, :arena, :pointer
     end
 
+    # Marshal 4.8 emission (TODO.restructure/21): the C side converts
+    # value records directly into Ruby's wire format; the binding
+    # materializes the whole graph with one core-C Marshal.load call
+    # 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
+
     # bulk build (TODO.impl/15 phase D): one call raises a document
     BUILD_SCALAR = 1
     BUILD_SEQ = 2
@@ -229,6 +248,9 @@ module Yeptris
     ERROR_MEMORY = 2
     ERROR_DEPTH = 3
     ERROR_ENCODING = 4
+    ERROR_IO = 5
     ERROR_ARG = 6
+    ERROR_UNSUPPORTED = 7
+    ERROR_INTERNAL = 8
   end
 end

data/lib/yeptris/node.rb

@@ -243,14 +243,48 @@ class Yeptris::Node
   end
 
   def to_ruby(memo = nil)
-    # readonly documents memoize per node: repeated materialization
-    # of a shared subtree returns the SAME object at zero walk cost
+    # readonly documents memoize per node: a second materialization
+    # returns the SAME object (the readonly cache is the ground truth
+    # for alias identity across calls).
     if @document.readonly?
       rm = @document.readonly_memo
       cached = rm[node_id]
       return cached if cached
-
-      return rm[node_id] = to_ruby_walk({})
+    end
+    # Marshal fast path (TODO.restructure/21): one C call turns the
+    # whole subtree into Ruby objects, preserving alias identity via
+    # the object's own object-link table. Only at the TOP-LEVEL entry
+    # (memo nil): inside a recursive walk a partial marshal would
+    # materialize outside the shared memo and break alias identity.
+    # Falls back to the per-node FFI walk on constructs the format
+    # cannot express (merge keys, timestamps) and on older builds.
+    if Yeptris::FFI::MARSHAL && memo.nil?
+      result =
+        begin
+          out_p = ::FFI::MemoryPointer.new(:pointer)
+          olen_p = ::FFI::MemoryPointer.new(:size_t)
+          st = Yeptris::FFI.yeptris_marshal_node(@c_ptr, out_p, olen_p)
+          if st == Yeptris::FFI::ERROR_UNSUPPORTED
+            nil
+          elsif st != Yeptris::FFI::OK
+            raise Yeptris::ParseError, Yeptris::FFI.last_error_message
+          else
+            buf = out_p.read_pointer
+            len = olen_p.read_uint64
+            bytes = buf.read_bytes(len)
+            bytes.force_encoding(Encoding::ASCII_8BIT)
+            ::Marshal.load(bytes)
+          end
+        ensure
+          Yeptris::FFI.yeptris_marshal_free(out_p.read_pointer) if out_p
+        end
+      unless result.nil?
+        @document.readonly_memo[node_id] = result if @document.readonly?
+        return result
+      end
+    end
+    if @document.readonly?
+      return @document.readonly_memo[node_id] = to_ruby_walk({})
     end
     to_ruby_walk(memo || {})
   end

data/lib/yeptris/valueml.rb

@@ -87,6 +87,35 @@ module Yeptris
       end
     end
 
+    # The Marshal fast path (TODO.restructure/21): the C side emits
+    # Ruby Marshal 4.8 bytes; one Marshal.load call (a core-C routine)
+    # materializes the whole object graph. ~10x faster than walking
+    # the columns in pure Ruby on JSON-shaped input; ~5x on YAML. Falls
+    # back to load_all_columns on the constructs the format cannot
+    # express (merge keys, timestamps — rare; the record walk handles
+    # them). Feature-detected: older libyeptris returns the walk.
+    def load_all_marshal(yaml, schema: :compat_11, mode: :first)
+      yaml = Yeptris.read_input(yaml)
+      yaml = yaml.to_s
+      out_p = ::FFI::MemoryPointer.new(:pointer)
+      olen_p = ::FFI::MemoryPointer.new(:size_t)
+      mode_id = mode == :all ? FFI::MARSHAL_ALL_DOCS : FFI::MARSHAL_FIRST_DOC
+      st = FFI.yeptris_marshal(
+        yaml, yaml.bytesize,
+        schema == :compat_11 ? FFI::SCHEMA_11_COMPAT : FFI::SCHEMA_12_CORE,
+        mode_id, out_p, olen_p
+      )
+      return nil if st == FFI::ERROR_UNSUPPORTED
+      raise ParseError, FFI.last_error_message if st != FFI::OK
+      buf = out_p.read_pointer
+      len = olen_p.read_uint64
+      bytes = buf.read_bytes(len)
+      bytes.force_encoding(Encoding::ASCII_8BIT)
+      ::Marshal.load(bytes)
+    ensure
+      FFI.yeptris_marshal_free(buf) if buf && !buf.null?
+    end
+
     def load(yaml, schema: :compat_11)
       docs = load_all(yaml, schema: schema)
       docs.empty? ? nil : docs.first
@@ -162,6 +191,12 @@ module Yeptris
           end
           slot(docs, stack, pending_key, pending_key_tag, v, merge_target, flat[i + IS_KEY], flat[i + TAG])
         when V_NULL
+          # the pending anchor binds to the null (an anchored empty
+          # scalar) — without this it would leak onto the next value
+          if pending_anchor
+            anchors[pending_anchor] = nil
+            pending_anchor = nil
+          end
           slot(docs, stack, pending_key, pending_key_tag, nil, merge_target, flat[i + IS_KEY], flat[i + TAG])
         when V_TS
           v = Materializer.parse_timestamp(arena.byteslice(flat[i + OFF], flat[i + LEN]))
@@ -315,6 +350,10 @@ module Yeptris
           end
           slot(docs, stack, pending_key, pending_key_tag, v, merge_target, ikeys[i], tags[i])
         when V_NULL
+          if pending_anchor
+            anchors[pending_anchor] = nil
+            pending_anchor = nil
+          end
           slot(docs, stack, pending_key, pending_key_tag, nil, merge_target, ikeys[i], tags[i])
         when V_TS
           v = Materializer.parse_timestamp(arena.byteslice(offs[i], lens[i]))

data/lib/yeptris/yaml.rb

@@ -20,10 +20,14 @@ module Yeptris
       _drain_all(yaml, schema)
     end
 
-    # The columnar drain when the loaded libyeptris has it (>= 0.1.2
-    # era builds), the record drain otherwise — one code path, the
-    # fastest the library offers.
+    # The Marshal fast path when the loaded libyeptris has it (>= 0.1.11
+    # era builds), falling back to the columnar drain and finally the
+    # record drain — one code path, the fastest the library offers.
     def _drain_all(yaml, schema)
+      if FFI::MARSHAL
+        result = ValueML.load_all_marshal(yaml, schema: schema, mode: :all)
+        return result unless result.nil?
+      end
       if FFI::COLUMNS
         ValueML.load_all_columns(yaml, schema: schema)
       else

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.1.10.0".freeze
+  VERSION = "0.1.11.0".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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.1.10.0
+  version: 0.1.11.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-06 00:00:00.000000000 Z
+date: 2026-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi