yeptris 0.2.3.1-aarch64-linux → 0.2.5.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b81fde0cf18e3da68e631f46189f2a63cd34059bec03f27ee6d6c3618c3fda65
-  data.tar.gz: 3bffc4c5d902f2f561cc46f43fd49f953dc6171ea10f075c3b31b699dad8dabb
+  metadata.gz: 607330f49f5f86cf870d5d4512934db643f6296be3624221e0493e5e7266bf9e
+  data.tar.gz: 8e2edb0acd3d681cbe673e0a395e0978b168bff5e4f2194e6a822daf3c816580
 SHA512:
-  metadata.gz: fe74c81497443546719e865d53dcfe5a21626e386a041644c037a8aed3e535eed0976ca3543cb01a7d9332dd43d5eb3609bcb491238b3ba829d2eacfb913c277
-  data.tar.gz: '08f02f4bd16dbcf01cf11e88a00c779dc12a297f7c8faee22b4e409fdbcf33364bb2b353ee528d2116e0c047245457715e2a455ff0d224dc5ea368f7fc3dc2e5'
+  metadata.gz: 4ef4f9db3563932be9244404b66742e6187271e0f6ec0f189a24c1edb6fc5a2c9aa600cfc1611157e0d42b3f432ba74b45ba81546dd459d61075528b72b0366e
+  data.tar.gz: 236554c32376824bf59a8cf2f44b0307621f34337cc8ef0738612f80a01df044c2a7148bc8358a617ab972d7c9aed3848f0181e513a05d68125babcd7484efe5

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,104 @@ 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
+
+    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 = []
+      stack = []
+      key_sets = STRICT_DUPLICATE_KEYS ? [{}] : nil
+      pending_key = nil
+      i = 1 # record 0 is the DOC boundary
+      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 = src.byteslice(offs[i], lens[i])
+          text.force_encoding(Encoding::UTF_8) unless utf8
+          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 +240,78 @@ 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
+
+    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 = []
+      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)
+      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)
+      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
+
+    def place_obj(obj, emit, blob, off)
+      case obj
+      when Hash
+        emit.call(::Yeptris::FFI::BUILD_MAP, 0, 0, 0)
+        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)
+        end
+        emit.call(::Yeptris::FFI::BUILD_END, 0, 0, 0)
+      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)
+      when String
+        scalar_json(obj, ::Yeptris::FFI::STYLE_DOUBLE_QUOTED, emit, 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)
+      when Date, Time
+        scalar_json(obj.iso8601, ::Yeptris::FFI::STYLE_DOUBLE_QUOTED, emit, 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)
+      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.2.5.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.2.5.1
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi