yeptris 0.2.3.1 → 0.3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e7e8a45fb4c7fd7af6bd778b16f1078495940f2c0d91e04c868108646cb6b77
-  data.tar.gz: de46c9de2194fc0beeb732f3b6063552170a54fd3a0ec4cb2c9b6221e2b8b905
+  metadata.gz: 9bfaf328e06609c6e368624b78b6e474f90c7d082512cf0daf1a7d80f843a1fa
+  data.tar.gz: 907187b75e0f02aba15d0e1c0233e2bfd1a63424748d485c90021ef5982b178e
 SHA512:
-  metadata.gz: 4e73dd947751f73310a9d7fc74aed2e2550fbd24fd6b01ceeff5f87cf18e29ab388bc7993b63b0c1edf65c19d5ec086f26a30360dec8debcb7dbfec65c2b86da
-  data.tar.gz: a5acc0eb5856e874548186f0bcb2ae063d98693053f9c33904c9c337c3139e8be729bedc5cbb0b4997d63d815ace715777ca8d3fa245fc0a9342854e03379b99
+  metadata.gz: 4db215da8852d32bff2177c20c0b2e56add31949806bff89dfb1bbc3e9de6566bcdaeaf6d88c8ee379b05dfb49a09514348943ddf6c0f038272db5dccf96e28c
+  data.tar.gz: 710e3e89f4463a49b8ff4e4e823f30b23be01c2951cc45711412fe88436df4dc597df2992121ca35e6a997171bf007a24d807181cad8a32c68d15f995726f7f4

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,17 @@ 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, four bulk columns, spans borrow
+    # the caller's string (no arena copy, no second validating parse).
+    class JsonTape < ::FFI::Struct
+      layout :count, :size_t, :kinds, :pointer, :offs, :pointer,
+             :lens, :pointer, :vals, :pointer, :int_min, :int64, :_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_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 +185,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,152 @@ 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_BOOL = 2
+    T_INT = 3
+    T_FLOAT = 4
+    T_STR = 5
+    T_SEQ_OPEN = 6
+    T_MAP_OPEN = 7
+    T_CLOSE = 8
+
+    # 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*")
+      raw = tape[:vals].read_bytes(n * 8)
+      vals_i = raw.unpack("q<*")
+      vals_f = raw.unpack("E*")
+      # any integer text beyond int64: every INT rebuilds from its span
+      # (exact Bignum; JSON.parse parity)
+      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_BOOL
+          v = vals_i[i] == 1
+          place(docs, stack, pending_key) { v }
+          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 +288,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.3.1".freeze
+  VERSION = "0.3.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

metadata

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