yeptris 0.2.5.3-aarch64-linux → 0.4.0.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53ba5f8ec2b0bce5440f6c728f78af3703a0ea3656b8c752a6bcacaf3362528f
-  data.tar.gz: e6ac1792bbf42a5bec4fbe2bcebdd060b22a21a0be62decfeea59216301c70a6
+  metadata.gz: b0564531041910fb120994e2f4cac8c9f3ddf0b176bf5ae9ca3289cb58f6ac87
+  data.tar.gz: 4b6da94d1b0706fdfdd597bc173ca9556e26482a517b391670ef2bb1471f17df
 SHA512:
-  metadata.gz: eeb00725be0541b489ace917c0e45480f0bf17056adaadb39835c9cdcce0bb44885fcf899624bc8d3d4331547b16c351ded8122783141b9acff641c6f126e701
-  data.tar.gz: add571ff504fd8ae8e5b1ee899ac8029762ee138277cd6ccd0830cdd9fd7a18126f5f3a8d13fd24736fe7f7e88ae551bfc989598ce071b34c087d1a93f174c89
+  metadata.gz: 47c6f2bfe6920039b2e2e0a69f84688cac61bd11e61df76d1f9ec39ccfad227ff5a831b0b7bdbc644829c8dd364bd4b112b7b54183758dee182f66f325371350
+  data.tar.gz: 1e7e5b9bbe7b38b3db23b7c16bf03f3981178f6e52f2db99e091a5560c21c2a98a50823b9598bbeb4d93bb14302c34a3f1e5e2fe97eb0de5c3b8c6ac873cc36f

data/ext/build_windows_native.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Builds the native materializer DLL for the CURRENT Ruby and
+# installs it under its minor-versioned name
+# (lib/yeptris/native-<major.minor>.so).
+#
+# The leptris-ruby Windows lesson (#207/#227): a PE DLL cannot
+# resolve Ruby imports lazily — it must bind the build Ruby's
+# x64-ucrt-rubyNNN.dll. One DLL per supported minor therefore ships
+# in the Windows platform gems, and the loader in lib/yeptris.rb
+# picks by RUBY_VERSION at require. Ruby 3.3 has no arm64 build:
+# that cell ships no artifact and falls back loudly to the FFI
+# ladder.
+#
+# Standalone by design: the release workflow runs this under each
+# Ruby minor (3.3/3.4/4.0) with no bundler context.
+
+require "rbconfig"
+require "fileutils"
+
+root = File.expand_path("..", __dir__)
+ext_dir = File.join(root, "ext", "yeptris_native")
+minor = RUBY_VERSION[/\A\d+\.\d+/]
+
+Dir.chdir(ext_dir) do
+  system(RbConfig.ruby, "extconf.rb") or abort "extconf failed under #{RUBY_VERSION}"
+  # mkmf's link binds the CURRENT Ruby's runtime DLL — exactly
+  # what the versioned naming is for.
+  success = system("make")
+  abort "make failed under #{RUBY_VERSION}" unless success
+  so = Dir.glob("native.{so,dll}").first
+  abort "native bundle not produced under #{RUBY_VERSION}" unless so
+  dest = File.join(root, "lib", "yeptris", "native-#{minor}.so")
+  # The artifact must reference only this minor's Ruby DLL.
+  imported = `strings #{so} 2>/dev/null`[/[a-z0-9-]*ruby\d{3,}\.dll/i]
+  if imported && !imported.include?("ruby#{minor.delete('.')}")
+    abort "#{so} imports #{imported} but was built under #{RUBY_VERSION} — refuse to mis-name it"
+  end
+  FileUtils.cp(so, dest)
+  puts "Installed native materializer for Ruby #{minor} -> #{dest} (#{imported || 'no ruby dll string found'})"
+end

data/lib/yeptris/ffi.rb

@@ -60,15 +60,19 @@ module Yeptris
     attach_function :yeptris_parse_json, %i[pointer size_t yeptris_status_out], :yeptris_document
 
     # The JSON tape (TODO.restructure/85; the JSON surface's load
-    # engine — issue #81): ONE call, four bulk columns, spans borrow
+    # engine — issue #81): ONE call, three bulk columns, spans borrow
     # the caller's string (no arena copy, no second validating parse).
+    # v2 records: numbers are spans at parse; yeptris_tape_convert
+    # materializes them in one bulk call.
     class JsonTape < ::FFI::Struct
       layout :count, :size_t, :kinds, :pointer, :offs, :pointer,
-             :lens, :pointer, :vals, :pointer, :int_min, :int64, :_block, :pointer
+             :lens, :pointer, :int_min, :int64, :_src, :pointer, :_srclen, :size_t,
+             :_block, :pointer
     end
 
     attach_function :yeptris_parse_json_tape, %i[pointer size_t pointer], :int
     attach_function :yeptris_tape_free, [:pointer], :void
+    attach_function :yeptris_tape_convert, %i[pointer size_t size_t pointer pointer], :size_t
 
     attach_function :yeptris_document_free, [:yeptris_document], :void
     attach_function :yeptris_document_count, [:yeptris_document], :size_t

data/lib/yeptris/json.rb

@@ -46,13 +46,63 @@ module Yeptris
     # three, which is where medium/large throughput went).
     T_DOC = 0
     T_NULL = 1
-    T_BOOL = 2
-    T_INT = 3
-    T_FLOAT = 4
-    T_STR = 5
-    T_SEQ_OPEN = 6
-    T_MAP_OPEN = 7
-    T_CLOSE = 8
+    T_TRUE = 2
+    T_FALSE = 3
+    T_INT = 4
+    T_FLOAT = 5
+    T_STR = 6
+    T_SEQ_OPEN = 7
+    T_MAP_OPEN = 8
+    T_CLOSE = 9
+
+    # The tape keeps RAW string spans (escapes untouched — the C
+    # contract); the walk decodes them here. The hot path (no
+    # backslash) returns the slice untouched.
+    SIMPLE_ESCAPES = {
+      '"' => '"'.b, "\\" => "\\".b, "/" => "/".b, "b" => "\b".b, "f" => "\f".b,
+      "n" => "\n".b, "r" => "\r".b, "t" => "\t".b
+    }.freeze
+
+    def decode_span(src, off, len)
+      s = src.byteslice(off, len)
+      s.force_encoding(Encoding::UTF_8)
+      return s unless s.include?("\\")
+
+      b = s.b
+      out = +"".b
+      i = 0
+      n = b.bytesize
+      while i < n
+        c = b.getbyte(i)
+        if c != 0x5C || i + 1 >= n
+          out << c
+          i += 1
+          next
+        end
+        e = b.getbyte(i + 1)
+        if e != 0x75 # simple escape
+          ch = e.chr
+          out << (SIMPLE_ESCAPES[ch] || ch)
+          i += 2
+          next
+        end
+        cp = b.byteslice(i + 2, 4).to_i(16)
+        if cp >= 0xD800 && cp <= 0xDBFF && i + 12 <= n &&
+           b.getbyte(i + 6) == 0x5C && b.getbyte(i + 7) == 0x75
+          lo = b.byteslice(i + 8, 4).to_i(16)
+          if lo >= 0xDC00 && lo <= 0xDFFF
+            cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00)
+            i += 12
+          else
+            i += 6
+          end
+        else
+          i += 6
+        end
+        out << [cp].pack("U").b
+      end
+      out.force_encoding(Encoding::UTF_8)
+    end
 
     def tape_engine(source)
       tape = ::Yeptris::FFI::JsonTape.new
@@ -71,11 +121,16 @@ module Yeptris
       kinds = tape[:kinds].read_bytes(n).unpack("C*")
       offs = tape[:offs].read_bytes(n * 4).unpack("V*")
       lens = tape[:lens].read_bytes(n * 4).unpack("V*")
-      raw = tape[:vals].read_bytes(n * 8)
-      vals_i = raw.unpack("q<*")
-      vals_f = raw.unpack("E*")
+      # v2: parse records number spans only — ONE bulk convert call
+      # materializes them (per-number FFI calls would sink the ladder)
+      ivp = ::FFI::MemoryPointer.new(:int64, n, true)
+      dvp = ::FFI::MemoryPointer.new(:double, n, true)
+      ::Yeptris::FFI.yeptris_tape_convert(tape, 0, n, ivp, dvp)
+      vals_i = ivp.read_bytes(n * 8).unpack("q<*")
+      vals_f = dvp.read_bytes(n * 8).unpack("E*")
       # any integer text beyond int64: every INT rebuilds from its span
-      # (exact Bignum; JSON.parse parity)
+      # (exact Bignum; JSON.parse parity) — int_min is set by the
+      # convert call above
       exact_ints = !tape[:int_min].zero?
       utf8 = src.encoding == Encoding::UTF_8
 
@@ -97,8 +152,7 @@ module Yeptris
           stack.pop
           key_sets&.pop
         when T_STR
-          text = src.byteslice(offs[i], lens[i])
-          text.force_encoding(Encoding::UTF_8) unless utf8
+          text = lens[i] == 0 ? +"".force_encoding(Encoding::UTF_8) : decode_span(src, offs[i], lens[i])
           if pending_key.nil? && !stack.empty? && stack.last.is_a?(Hash)
             if key_sets && key_sets.last.key?(text)
               raise ParseError, %(duplicate key "#{text}" in JSON object)
@@ -121,9 +175,8 @@ module Yeptris
           v = vals_f[i]
           place(docs, stack, pending_key) { v }
           pending_key = nil
-        when T_BOOL
-          v = vals_i[i] == 1
-          place(docs, stack, pending_key) { v }
+        when T_TRUE, T_FALSE # v2: the kind IS the value
+          place(docs, stack, pending_key) { kinds[i] == T_TRUE }
           pending_key = nil
         when T_NULL
           place(docs, stack, pending_key) { nil }
@@ -249,26 +302,15 @@ module Yeptris
     # and null stay plain), Symbols become their name.
     class DumpError < Error; end
 
-    ENTRY_BYTES = 12
-    MAP_ENTRY = [::Yeptris::FFI::BUILD_MAP, 0, 0, 0].pack("CCx2VV").freeze
-    SEQ_ENTRY = [::Yeptris::FFI::BUILD_SEQ, 0, 0, 0].pack("CCx2VV").freeze
-    END_ENTRY = [::Yeptris::FFI::BUILD_END, 0, 0, 0].pack("CCx2VV").freeze
-    CONT_ENTRY = { ::Yeptris::FFI::BUILD_MAP => MAP_ENTRY, ::Yeptris::FFI::BUILD_SEQ => SEQ_ENTRY,
-                   ::Yeptris::FFI::BUILD_END => END_ENTRY }.freeze
-
     def dump(obj)
-      parts = []
+      parts = String.new(encoding: Encoding::BINARY,
+                         capacity: 12 * 16) # 12-byte entries, appended in place
       blob = String.new(encoding: Encoding::BINARY)
       off = [0]
-      emit = lambda do |op, style, o, len|
-        parts << (o.zero? && len.zero? && style.zero? ? CONT_ENTRY[op] :
-                    [op, style, o, len].pack("CCx2VV"))
-      end
-      place_obj(obj, emit, blob, off)
+      place_obj(obj, parts, blob, off)
       doc = ::Yeptris::Document.create
-      buf = ::FFI::MemoryPointer.from_string(parts.join)
-      bblob = ::FFI::MemoryPointer.from_string(blob)
-      rc = doc.build_entries(buf, parts.length, bblob, blob.bytesize)
+      # FFI passes String args BY REFERENCE — no MemoryPointer copies
+      rc = doc.build_entries(parts, parts.bytesize / 12, blob, blob.bytesize)
       raise DumpError, "document_build failed: #{rc}" unless rc == ::Yeptris::FFI::OK
       out = ::Yeptris::FFI::JSON_EX ? doc.serialize_json_compact : doc.serialize_json
       # JSON.generate emits no trailing newline (the document writer does)
@@ -277,37 +319,51 @@ module Yeptris
       doc&.free
     end
 
-    def place_obj(obj, emit, blob, off)
+    F = ::Yeptris::FFI
+    MAP_E = [F::BUILD_MAP, 0, 0, 0].pack("CCx2VV").freeze
+    SEQ_E = [F::BUILD_SEQ, 0, 0, 0].pack("CCx2VV").freeze
+    END_E = [F::BUILD_END, 0, 0, 0].pack("CCx2VV").freeze
+    DQ = F::STYLE_DOUBLE_QUOTED
+    PL = F::STYLE_PLAIN
+    SC_DQ = [F::BUILD_SCALAR, DQ].pack("CCx2").freeze
+    SC_PL = [F::BUILD_SCALAR, PL].pack("CCx2").freeze
+
+    def place_obj(obj, parts, blob, off)
       case obj
       when Hash
-        emit.call(::Yeptris::FFI::BUILD_MAP, 0, 0, 0)
+        parts << MAP_E
         obj.each do |k, v|
           key = k.is_a?(String) ? k : k.is_a?(Symbol) ? k.name : k.to_s
-          scalar_json(key, ::Yeptris::FFI::STYLE_DOUBLE_QUOTED, emit, blob, off)
-          place_obj(v, emit, blob, off)
+          scalar_json(key, SC_DQ, parts, blob, off)
+          place_obj(v, parts, blob, off)
         end
-        emit.call(::Yeptris::FFI::BUILD_END, 0, 0, 0)
+        parts << END_E
       when Array
-        emit.call(::Yeptris::FFI::BUILD_SEQ, 0, 0, 0)
-        obj.each { |e| place_obj(e, emit, blob, off) }
-        emit.call(::Yeptris::FFI::BUILD_END, 0, 0, 0)
+        parts << SEQ_E
+        obj.each { |e| place_obj(e, parts, blob, off) }
+        parts << END_E
       when String
-        scalar_json(obj, ::Yeptris::FFI::STYLE_DOUBLE_QUOTED, emit, blob, off)
+        scalar_json(obj, SC_DQ, parts, blob, off)
       when Symbol
-        scalar_json(obj.name, ::Yeptris::FFI::STYLE_DOUBLE_QUOTED, emit, blob, off)
-      when Integer, Float, true, false, nil
-        text = obj.nil? ? "null" : obj.to_s
-        scalar_json(text, ::Yeptris::FFI::STYLE_PLAIN, emit, blob, off)
+        scalar_json(obj.name, SC_DQ, parts, blob, off)
+      when Integer, Float
+        scalar_json(obj.to_s, SC_PL, parts, blob, off)
+      when true
+        scalar_json("true", SC_PL, parts, blob, off)
+      when false
+        scalar_json("false", SC_PL, parts, blob, off)
+      when nil
+        scalar_json("null", SC_PL, parts, blob, off)
       when Date, Time
-        scalar_json(obj.iso8601, ::Yeptris::FFI::STYLE_DOUBLE_QUOTED, emit, blob, off)
+        scalar_json(obj.iso8601, SC_DQ, parts, blob, off)
       else
         raise DumpError, "cannot dump #{obj.class}: unsupported object " \
                          "(JSON.generate calls to_json on custom types)"
       end
     end
 
-    def scalar_json(text, style, emit, blob, off)
-      emit.call(::Yeptris::FFI::BUILD_SCALAR, style, off[0], text.bytesize)
+    def scalar_json(text, prefix, parts, blob, off)
+      parts << (prefix + [off[0], text.bytesize].pack("VV"))
       blob << text
       off[0] += text.bytesize
     end

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.2.5.3".freeze
+  VERSION = "0.4.0.1".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
@@ -70,8 +70,21 @@ end
 # Optional C-API materializer (TODO.restructure/22): fused visit →
 # Ruby objects via the Ruby C API. Feature-detected — LoadError leaves
 # the FFI ladder (Marshal → columns → records) as the sole path.
+# Windows names the artifact per Ruby minor (the leptris-ruby #207/
+# #227 lesson): a PE DLL must bind its build Ruby's runtime, so one
+# DLL per supported minor ships and RUBY_VERSION selects. A missing
+# cell (Ruby 3.3 arm64 has no build) falls back LOUDLY to the ladder.
 begin
-  require "yeptris/native"
-rescue LoadError
+  if Gem.win_platform?
+    require "yeptris/native-#{RUBY_VERSION[/\A\d+\.\d+/]}"
+  else
+    require "yeptris/native"
+  end
+rescue LoadError => e
+  if Gem.win_platform?
+    warn "yeptris: no precompiled native materializer for Ruby " \
+         "#{RUBY_VERSION[/\A\d+\.\d+/]} on this platform " \
+         "(#{e.message}); the FFI ladder carries the load"
+  end
   # FFI ladder only
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.2.5.3
+  version: 0.4.0.1
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-14 00:00:00.000000000 Z
+date: 2026-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -34,6 +34,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.adoc
+- ext/build_windows_native.rb
 - ext/yeptris_native/extconf.rb
 - ext/yeptris_native/json_ruby.c
 - ext/yeptris_native/yeptris_native.c