yeptris 0.2.4.1 → 0.4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17b8f09d9419550f61e2bd1b1c9afd7b3b0b9d4924ad9f294ef5c17a58bc89ce
-  data.tar.gz: 47b03032432acdac62836c9cab157df1b6d6aee93c5390f05211956f1f987114
+  metadata.gz: 8d15146500e202e6c6ce0b97073284d0ac31f78df2b0260c2bac7b1e733747df
+  data.tar.gz: 8521281dbdaffdd88551de237741f773a02381613a4b9640c34d1b46dd1e9369
 SHA512:
-  metadata.gz: 4f3cbf301048a1e1eff62fde861639feccb299ef2ea1a57952f379ed37d08d4c9e302afaae11cfc5c31a5168b709a76823de30d2a594052f5b5583bbd314caf7
-  data.tar.gz: cc04e336c871400914dafc76e55eb76236ecf20c2ad7b831d5f93ec3af023069c1c5bb0fb967595a24268f6e9215590e80bc43e4c0bbe02ae79918d9756b63d8
+  metadata.gz: c2b9eaa728ead723567966836a16eee18a48f5b5bbf8c2d5f1f3dc4d7cdcee69ce237cd19c7eabf4fbb55abf1e72437697ec6f7fe96e3704b342fb7a8d3da8ff
+  data.tar.gz: a857fd5b3e2d86f2b8f142263cb609a00eb21458a5b035b681fa0c9f24097ed11f7162c69ad20b3eaf8faea47d49e03d999377f8bacde847416b79b202469e24

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/document.rb

@@ -153,6 +153,11 @@ class Yeptris::Document
     Yeptris::FFI::Owned.string(ptr, len)
   end
 
+  def serialize_json_compact
+    len = ::FFI::MemoryPointer.new(:uint64)
+    Yeptris::FFI::Owned.string(Yeptris::FFI.yeptris_serialize_json_ex(@c_ptr, len, 1), len)
+  end
+
   def serialize_json
     ensure_alive!
     len = ::FFI::MemoryPointer.new(:uint64)

data/lib/yeptris/ffi.rb

@@ -59,6 +59,21 @@ module Yeptris
                     %i[pointer size_t pointer yeptris_status_out], :yeptris_document
     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, 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, :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
     attach_function :yeptris_document_root, [:yeptris_document, :size_t], :yeptris_node
@@ -174,6 +189,15 @@ module Yeptris
                     %i[yeptris_document pointer pointer], :pointer
     attach_function :yeptris_serialize_json, %i[yeptris_document pointer], :pointer
 
+    # compact JSON generation (JSON.generate's shape); absent on
+    # libraries before v0.2.5 — the JSON surface feature-detects
+    JSON_EX = begin
+      attach_function :yeptris_serialize_json_ex, %i[yeptris_document pointer int], :pointer
+      true
+    rescue ::FFI::NotFoundError
+      false
+    end
+
     # Owned char* results (serialize*): one reader, freed exactly once.
     # The buffers are plain malloc'd C memory (the header contract says
     # "caller frees"), so the release is libc free.

data/lib/yeptris/json.rb

@@ -36,7 +36,157 @@ module Yeptris
           raise ParseError, e.message
         end
       end
-      strict_fallback(source)
+      tape_engine(source)
+    end
+
+    # The tape engine (issue #81): ONE call validates and materializes
+    # the record stream; the walk reads four bulk columns and slices
+    # strings straight out of the caller's source — no gate document,
+    # no recorder transform, no arena copy (the drain path paid all
+    # three, which is where medium/large throughput went).
+    T_DOC = 0
+    T_NULL = 1
+    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
+      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)
+      ensure
+        ::Yeptris::FFI.yeptris_tape_free(tape)
+      end
+    end
+
+    def walk_tape(src, tape)
+      n = tape[:count]
+      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*")
+      # 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) — int_min is set by the
+      # convert call above
+      exact_ints = !tape[:int_min].zero?
+      utf8 = src.encoding == Encoding::UTF_8
+
+      docs = [nil] # record 0 (DOC) pre-consumed — the root's slot
+      stack = []
+      key_sets = STRICT_DUPLICATE_KEYS ? [{}] : nil
+      pending_key = nil
+      i = 1
+      while i < n
+        case kinds[i]
+        when T_SEQ_OPEN
+          place(docs, stack, pending_key) { [] }
+          pending_key = nil
+        when T_MAP_OPEN
+          key_sets&.push({})
+          place(docs, stack, pending_key) { {} }
+          pending_key = nil
+        when T_CLOSE
+          stack.pop
+          key_sets&.pop
+        when T_STR
+          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)
+            end
+            key_sets&.last&.store(text, true)
+            pending_key = text
+          else
+            place(docs, stack, pending_key) { text }
+            pending_key = nil
+          end
+        when T_INT
+          if exact_ints
+            place(docs, stack, pending_key) { Integer(src.byteslice(offs[i], lens[i]), 10) }
+          else
+            v = vals_i[i]
+            place(docs, stack, pending_key) { v }
+          end
+          pending_key = nil
+        when T_FLOAT
+          v = vals_f[i]
+          place(docs, stack, pending_key) { v }
+          pending_key = nil
+        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 }
+          pending_key = nil
+        else
+          raise Error, "internal: impossible tape record #{kinds[i]}"
+        end
+        i += 1
+      end
+      docs.empty? ? nil : docs.first
     end
 
     # The always-available engine: the strict-JSON validator gates
@@ -143,6 +293,81 @@ module Yeptris
       docs.empty? ? nil : docs.first
     end
 
+    # ---- generation (issue #81) ------------------------------------------
+    #
+    # `dump` targets JSON.generate semantics for the core types: the
+    # object walk reuses YAML.dump's packed-entry bulk builder (one
+    # FFI build call), then the strict-JSON writer serializes —
+    # Strings ride DOUBLE_QUOTED (a "42" stays quoted; numbers, bools
+    # and null stay plain), Symbols become their name.
+    class DumpError < Error; end
+
+    def dump(obj)
+      parts = String.new(encoding: Encoding::BINARY,
+                         capacity: 12 * 16) # 12-byte entries, appended in place
+      blob = String.new(encoding: Encoding::BINARY)
+      off = [0]
+      place_obj(obj, parts, blob, off)
+      doc = ::Yeptris::Document.create
+      # 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)
+      out.end_with?("\n") ? out[0, out.bytesize - 1] : out
+    ensure
+      doc&.free
+    end
+
+    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
+        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, SC_DQ, parts, blob, off)
+          place_obj(v, parts, blob, off)
+        end
+        parts << END_E
+      when Array
+        parts << SEQ_E
+        obj.each { |e| place_obj(e, parts, blob, off) }
+        parts << END_E
+      when String
+        scalar_json(obj, SC_DQ, parts, blob, off)
+      when Symbol
+        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, 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, prefix, parts, blob, off)
+      parts << (prefix + [off[0], text.bytesize].pack("VV"))
+      blob << text
+      off[0] += text.bytesize
+    end
+
     def place(docs, stack, key)
       v = yield
       if stack.empty?

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.4.1".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.4.1
+  version: 0.4.0.1
 platform: ruby
 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