yeptris 0.2.0.1-aarch64-linux

data/lib/yeptris/ffi.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Yeptris
+  # Every public C declaration, attached exactly once (the leptris-ruby
+  # seam discipline: status checking and owned-pointer reading live in
+  # check_status / read_owned_string, never hand-rolled at call sites).
+  module FFI
+    extend ::FFI::Library
+
+    begin
+      ffi_lib [
+        ENV["YEPTRIS_LIB_PATH"],
+        File.expand_path("../../libyeptris.dylib", __dir__),
+        File.expand_path("../../libyeptris.so", __dir__),
+        File.expand_path("../../libyeptris.dll", __dir__),
+        "/usr/local/lib/libyeptris.dylib",
+        "/usr/local/lib/libyeptris.so",
+        "yeptris",
+      ].compact
+    rescue LoadError => e
+      raise LoadError, <<~MSG
+        yeptris: cannot load the libyeptris library.
+        Set YEPTRIS_LIB_PATH to a libyeptris.{so,dylib,dll}, or vendor
+        the library next to the gem's lib/ directory.
+        (Underlying error: #{e.message})
+      MSG
+    end
+
+    typedef :pointer, :yeptris_document
+    typedef :pointer, :yeptris_node
+    typedef :pointer, :yeptris_status_out
+    typedef :int, :yeptris_status
+
+    # YeptrisParseOptions (parse.h): schema, max_depth, strict,
+    # tab_policy, recover. ABI-frozen field order.
+    class ParseOptions < ::FFI::Struct
+      layout :schema, :int,
+             :max_depth, :int,
+             :strict, :int,
+             :tab_policy, :int,
+             :recover, :int
+    end
+
+    # yeptris_emit_options (emit.h): versioned by size.
+    class EmitOptions < ::FFI::Struct
+      layout :size, :uint32,
+             :canonical, :int,
+             :best_width, :int
+    end
+
+    attach_function :yeptris_version, [], :string
+
+    attach_function :yeptris_last_error, [:pointer, :pointer], :string
+
+    attach_function :yeptris_parse, %i[pointer size_t yeptris_status_out], :yeptris_document
+    attach_function :yeptris_parse_ex,
+                    %i[pointer size_t pointer yeptris_status_out], :yeptris_document
+    attach_function :yeptris_parse_json, %i[pointer size_t yeptris_status_out], :yeptris_document
+
+    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
+
+    # construction (TODO.impl/11 phase 3)
+    attach_function :yeptris_document_new, [], :yeptris_document
+    attach_function :yeptris_document_set_root,
+                    %i[yeptris_document yeptris_node], :int
+    attach_function :yeptris_node_new_mapping, [:yeptris_document], :yeptris_node
+    attach_function :yeptris_node_new_sequence, [:yeptris_document], :yeptris_node
+    attach_function :yeptris_node_new_scalar,
+                    %i[yeptris_document pointer size_t int], :yeptris_node
+    attach_function :yeptris_node_map_add,
+                    %i[yeptris_node pointer size_t yeptris_node], :int
+    attach_function :yeptris_node_map_set,
+                    %i[yeptris_node pointer size_t yeptris_node], :int
+    attach_function :yeptris_node_map_del, %i[yeptris_node pointer size_t], :int
+    attach_function :yeptris_node_seq_add, %i[yeptris_node yeptris_node], :int
+    attach_function :yeptris_node_seq_del, %i[yeptris_node size_t], :int
+    attach_function :yeptris_node_set_anchor, %i[yeptris_node pointer size_t], :int
+    attach_function :yeptris_node_set_tag, %i[yeptris_node pointer size_t], :int
+    attach_function :yeptris_node_new_alias,
+                    %i[yeptris_document yeptris_node pointer size_t], :yeptris_node
+
+    attach_function :yeptris_node_kind, [:yeptris_node], :int
+    attach_function :yeptris_node_id, [:yeptris_node], :uint32
+    attach_function :yeptris_node_value, %i[yeptris_node pointer], :pointer
+    attach_function :yeptris_node_style, [:yeptris_node], :int
+    attach_function :yeptris_node_tag, %i[yeptris_node pointer], :pointer
+    attach_function :yeptris_node_anchor, %i[yeptris_node pointer], :pointer
+    attach_function :yeptris_node_alias_target, [:yeptris_node], :yeptris_node
+    attach_function :yeptris_node_tag_id, [:yeptris_node], :int
+    attach_function :yeptris_node_int, %i[yeptris_node pointer], :yeptris_status
+    attach_function :yeptris_node_float, %i[yeptris_node pointer], :yeptris_status
+    attach_function :yeptris_node_bool, %i[yeptris_node pointer], :yeptris_status
+    attach_function :yeptris_node_seq_count, [:yeptris_node], :size_t
+    attach_function :yeptris_node_seq_at, %i[yeptris_node size_t], :yeptris_node
+    attach_function :yeptris_node_map_count, [:yeptris_node], :size_t
+    attach_function :yeptris_node_map_get, %i[yeptris_node pointer size_t], :yeptris_node
+    attach_function :yeptris_node_map_at,
+                    %i[yeptris_node size_t pointer pointer], :int
+
+    attach_function :yeptris_tag_uri, [:int], :string
+
+    # recorder (TODO.impl/12): bulk records + string arena, one drain
+    attach_function :yeptris_recorder_new, [], :pointer
+    attach_function :yeptris_recorder_new_ex, [:int], :pointer
+    attach_function :yeptris_recorder_feed,
+                    %i[pointer pointer size_t int], :int
+    attach_function :yeptris_recorder_records, %i[pointer pointer], :pointer
+    attach_function :yeptris_recorder_arena, %i[pointer pointer], :pointer
+    attach_function :yeptris_recorder_free, [:pointer], :void
+
+    # value stream (TODO.impl/15 phase F): one drain of pre-converted
+    # typed values — the materialization fast path
+    attach_function :yeptris_value_drain,
+                    %i[pointer size_t int pointer pointer pointer pointer], :int
+    attach_function :yeptris_value_free, %i[pointer pointer], :void
+
+    # Columnar drain (libyeptris > 0.1.1): the same stream as parallel
+    # typed buffers, one carved allocation. Feature-detected — the
+    # record API is the fallback on older libraries.
+    COLUMNS = begin
+      attach_function :yeptris_value_drain_columns, %i[pointer size_t int pointer], :int
+      attach_function :yeptris_value_free_columns, [:pointer], :void
+      true
+    rescue ::FFI::NotFoundError
+      false
+    end
+
+    class ValueColumns < ::FFI::Struct
+      layout :count, :size_t, :arena_len, :size_t,
+             :payloads, :pointer, :offs, :pointer, :lens, :pointer,
+             :kinds, :pointer, :tags, :pointer, :is_keys, :pointer,
+             :bools, :pointer, :arena, :pointer
+    end
+
+    # Marshal 4.8 emission (TODO.restructure/21): the C side converts
+    # value records directly into Ruby's wire format; the binding
+    # materializes the whole graph with one core-C Marshal.load call
+    # instead of walking per-value records in pure Ruby. Same feature-
+    # detect discipline as the columnar drain (older libraries fall
+    # back to the record walk).
+    MARSHAL = begin
+      MARSHAL_ALL_DOCS = 0
+      MARSHAL_FIRST_DOC = 1
+      attach_function :yeptris_marshal,
+                      %i[pointer size_t int int pointer pointer], :int
+      attach_function :yeptris_marshal_node,
+                      %i[yeptris_node pointer pointer], :int
+      attach_function :yeptris_marshal_free, [:pointer], :void
+      true
+    rescue ::FFI::NotFoundError
+      false
+    end
+
+    # bulk build (TODO.impl/15 phase D): one call raises a document
+    BUILD_SCALAR = 1
+    BUILD_SEQ = 2
+    BUILD_MAP = 3
+    BUILD_END = 4
+
+    # the ABI-pinned shape; the bulk builder packs these bytes
+    # directly (12 per entry)
+    class BuildEntry < ::FFI::Struct
+      layout op: :uint8, style: :uint8, reserved: :uint16, off: :uint32, len: :uint32
+    end
+    attach_function :yeptris_document_build,
+                    %i[yeptris_document pointer size_t pointer size_t], :int
+
+    attach_function :yeptris_serialize, %i[yeptris_document pointer], :pointer
+    attach_function :yeptris_serialize_ex,
+                    %i[yeptris_document pointer pointer], :pointer
+    attach_function :yeptris_serialize_json, %i[yeptris_document pointer], :pointer
+
+    # 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.
+    attach_function :c_free, :free, [:pointer], :void
+
+    module Owned
+      module_function
+
+      # Reads a NUL-terminated malloc'd C string into an Encoding
+      # UTF_8 String, then frees the buffer. len_out (nullable) is a
+      # MemoryPointer carrying the byte length from the producing call.
+      def string(ptr, len_out = nil)
+        return nil if ptr.null?
+
+        len = len_out&.read_uint64
+        s = if len && len > 0
+              ptr.read_bytes(len).force_encoding(Encoding::UTF_8)
+            else
+              ptr.read_string.force_encoding(Encoding::UTF_8)
+            end
+        ::Yeptris::FFI.c_free(ptr)
+        s
+      end
+    end
+
+    module_function
+
+    # Non-OK status -> ParseError carrying the C error channel's
+    # message with line/column. NULL-document failures route through
+    # here too (parse detail lives on the same channel).
+    def check_status(status, action)
+      return if status.zero?
+
+      raise Yeptris::ParseError, "#{action} failed: #{last_error_message}"
+    end
+
+    def last_error_message
+      line = ::FFI::MemoryPointer.new(:uint32)
+      col = ::FFI::MemoryPointer.new(:uint32)
+      msg = yeptris_last_error(line, col)
+      detail = msg.to_s
+      l = line.read_uint32
+      c = col.read_uint32
+      l.positive? ? "#{detail} at line #{l}, column #{c}" : detail
+    end
+
+    # Pinned enum values (test_abi): the constants the binding relies
+    # on without a C header at runtime.
+    NODE_SCALAR = 0
+    NODE_SEQUENCE = 1
+    NODE_MAPPING = 2
+    NODE_ALIAS = 3
+
+    STYLE_PLAIN = 1
+    STYLE_SINGLE_QUOTED = 2
+    STYLE_DOUBLE_QUOTED = 3
+    STYLE_LITERAL = 4
+    STYLE_FOLDED = 5
+
+    TAG_STR = 0
+    TAG_INT = 1
+    TAG_FLOAT = 2
+    TAG_BOOL = 3
+    TAG_NULL = 4
+    TAG_TIMESTAMP = 5
+
+    SCHEMA_12_CORE = 0
+    SCHEMA_11_COMPAT = 1
+
+    OK = 0
+    ERROR_PARSE = 1
+    ERROR_MEMORY = 2
+    ERROR_DEPTH = 3
+    ERROR_ENCODING = 4
+    ERROR_IO = 5
+    ERROR_ARG = 6
+    ERROR_UNSUPPORTED = 7
+    ERROR_INTERNAL = 8
+  end
+end

data/lib/yeptris/json.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Yeptris
+  # The STRICT JSON surface (TODO.restructure/31).
+  #
+  # `Yeptris::JSON.load` targets EXACT `JSON.parse` semantics — that
+  # is its parity target, spec-pinned (spec/json_parity_spec.rb).
+  # It is deliberately separate from Yeptris::YAML: the YAML surface
+  # keeps the Psych contract for every input (JSON-shaped included),
+  # so the two never drift into each other's semantics.
+  #
+  # Engines, fastest first (both exact — the parity spec runs against
+  # whichever is loaded):
+  # 1. the native materializer (fused C scan → VALUE; opt-in build)
+  # 2. the record drain + strict conversion walk (always available)
+  module JSON
+    class Error < ::Yeptris::Error; end
+    class ParseError < Error; end
+
+    # json gem 3.0 made duplicate keys an error by DEFAULT; 2.x is
+    # last-wins. The parity target is the RESOLVED json gem's own
+    # behavior — strictness follows it (issue #37, found by canon's
+    # CI where json 3.0.0 resolved while the dev box had 2.x).
+    require "json"
+    STRICT_DUPLICATE_KEYS = Gem::Version.new(::JSON::VERSION) >= Gem::Version.new("3")
+
+    module_function
+
+    def load(source)
+      source = ::Yeptris.read_input(source)
+      source = source.to_s
+      if defined?(::Yeptris::Native)
+        begin
+          return ::Yeptris::Native.load_json(source, STRICT_DUPLICATE_KEYS)
+        rescue ::Yeptris::ParseError => e
+          raise ParseError, e.message
+        end
+      end
+      strict_fallback(source)
+    end
+
+    # The always-available engine: the strict-JSON validator gates
+    # (parse_json raises on anything RFC 8259 rejects), then the
+    # value records convert WITHOUT the Psych quirk table — floats
+    # are always Floats, bools always bools ("1e3" is 1000.0 here
+    # and a String on the YAML surface; each surface is its own
+    # contract).
+    def strict_fallback(source)
+      begin
+        gate = ::Yeptris::Document.parse_json(source)
+      rescue ::Yeptris::ParseError => e
+        raise ParseError, e.message
+      end
+      begin
+        cols = ::Yeptris::FFI::ValueColumns.new
+        st = ::Yeptris::FFI.yeptris_value_drain_columns(
+          source, source.bytesize, ::Yeptris::FFI::SCHEMA_12_CORE, cols
+        )
+        raise ParseError, ::Yeptris::FFI.last_error_message if st != ::Yeptris::FFI::OK
+
+        begin
+          walk_strict(cols, STRICT_DUPLICATE_KEYS)
+        ensure
+          ::Yeptris::FFI.yeptris_value_free_columns(cols)
+        end
+      ensure
+        gate.free
+      end
+    end
+
+    # Placement mechanics mirror ValueML.walk_columns; the CONVERSION
+    # is the strict-JSON one (no ':sym' scan, no y/n quirk, no
+    # dot-required floats). Anchors/aliases/timestamps cannot occur
+    # in strict JSON — reaching them is an internal error.
+    def walk_strict(cols, strict_dup = STRICT_DUPLICATE_KEYS)
+      n = cols[:count]
+      kinds = cols[:kinds].read_bytes(n).unpack("C*")
+      ikeys = cols[:is_keys].read_bytes(n).unpack("C*")
+      bools = cols[:bools].read_bytes(n).unpack("C*")
+      offs = cols[:offs].read_bytes(n * 4).unpack("V*")
+      lens = cols[:lens].read_bytes(n * 4).unpack("V*")
+      pays = cols[:payloads].read_bytes(n * 8).unpack("q<*")
+      arena = cols[:arena_len].zero? ? +"" : cols[:arena].read_bytes(cols[:arena_len])
+      arena.force_encoding(Encoding::UTF_8)
+
+      docs = []
+      stack = []
+      key_sets = strict_dup ? [{}] : nil
+      pending_key = nil
+      i = 0
+      while i < n
+        case kinds[i]
+        when ValueML::DOC
+          docs.push(nil)
+        when ValueML::SEQ_OPEN
+          place(docs, stack, pending_key) { [] }
+          pending_key = nil
+        when ValueML::MAP_OPEN
+          key_sets&.push({})
+          place(docs, stack, pending_key) { {} }
+          pending_key = nil
+        when ValueML::CLOSE
+          stack.pop
+          key_sets&.pop
+        when ValueML::V_STR
+          text = arena.byteslice(offs[i], lens[i])
+          if ikeys[i] == 1 && !stack.empty? && stack.last.is_a?(Hash)
+            if strict_dup && key_sets.last.key?(text)
+              raise ParseError, %(duplicate key "#{text}" in JSON object)
+            end
+            key_sets&.last&.store(text, true)
+            pending_key = text
+          else
+            # Records carry int64 payloads: an integer-beyond-int64
+            # degrades to a PLAIN string (b==1). In strict JSON a
+            # plain (unquoted) scalar can ONLY be a number — every
+            # real string is quoted and arrives b==0 — so rebuild the
+            # exact Integer (JSON.parse parity, Bignum included).
+            if bools[i] == 1
+              place(docs, stack, pending_key) { Integer(text, 10) }
+            else
+              place(docs, stack, pending_key) { text }
+            end
+            pending_key = nil
+          end
+        when ValueML::V_INT
+          place(docs, stack, pending_key) { pays[i] }
+          pending_key = nil
+        when ValueML::V_FLOAT
+          place(docs, stack, pending_key) { [pays[i]].pack("q<").unpack1("E") }
+          pending_key = nil
+        when ValueML::V_BOOL
+          place(docs, stack, pending_key) { bools[i] == 1 }
+          pending_key = nil
+        when ValueML::V_NULL
+          place(docs, stack, pending_key) { nil }
+          pending_key = nil
+        else
+          raise Error, "internal: impossible record #{kinds[i]} in strict JSON"
+        end
+        i += 1
+      end
+      docs.empty? ? nil : docs.first
+    end
+
+    def place(docs, stack, key)
+      v = yield
+      if stack.empty?
+        docs[-1] = v
+      elsif key
+        stack.last[key] = v
+      else
+        stack.last.push(v)
+      end
+      stack.push(v) if v.is_a?(Array) || v.is_a?(Hash)
+      v
+    end
+  end
+end