yeptris 0.2.5.2-aarch64-linux → 0.3.0.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ece26be832b852b794f03b406e5ac06aebdee16cf41021fa900e0801a9de9464
-  data.tar.gz: 4991692715cf5282d84ddb75acc1b11b4579b7e8864a700a62bf86f7b9b101c6
+  metadata.gz: 4639faf83e98440ebb4973f881db719fb6629ccbf7949f8bed6052e5be53184a
+  data.tar.gz: a0b7ed9983184783e89a590cc317b147c6eb41e39ab6801c41dd744391573020
 SHA512:
-  metadata.gz: 05bb798fd87722f7e06e935757b4b6f620ef3920bfadc1a8048f00c4f44a5fd07262440d681f3d1793be9161dae2ed8975a14956808abafa4608a7ca053a8634
-  data.tar.gz: efb02f91d9f8ff06129b7fa97c92017ff694c232c8d03025e5b84536566493de44e120a020b339bcbce54011704b23777b81755c6f5c0a4d95597d18eea70179
+  metadata.gz: 775dd41728fd5171efb2a0e895498a7c2f98dc6cba9c68c0593c476d3b320c0a17e0f9d83efe69bae90b5cadcce53ab8c516d54eb0478065095aa6a2f37f802c
+  data.tar.gz: e11d2650357819532da00d1749b1fcfda1d948886f9d445b106b9eba22dab88ec4d688daab5bb0ca921500d9ca1eadf1fdec8ae8511a4287506c74822f53ba28

data/lib/yeptris/json.rb

@@ -54,6 +54,55 @@ module Yeptris
     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)
@@ -73,7 +122,7 @@ module Yeptris
       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")
+      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?
@@ -97,8 +146,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)
@@ -249,26 +297,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 +314,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.2".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.5.2
+  version: 0.3.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-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi