yeptris 0.2.1.1-aarch64-linux → 0.2.1.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a6bb083838e4a5c101af3dda7b8872f7ddc9c17b5926e7f53d8dc89267563b2
-  data.tar.gz: e3b3ed68162b71af5b6f5549f03d6fbfd527f57f907a8fc8232f9fdeffcd0209
+  metadata.gz: f876e15dade67cc5cbec6eba74a48c6936d636200ed3111f79d4da6b2402813d
+  data.tar.gz: ba9dc5f7735cd6d770d97e6f091ccf4c0931652628d8530a6563e9d463580a24
 SHA512:
-  metadata.gz: 2de1413ca27b42df0e9cde8bcc3df01298152f9984c8d3085503d914b0566b39d1da66d3acf66beba4427c8cd4980875a4d7b94144250f8232765064f90211d2
-  data.tar.gz: 74ec82d60158db3e4428ea083b11cb9a25ac8efe31f72c9760ea713afb4e763833669d7941b88015d389eea75c9fda8c4a3e00aaea1a43afad1d71e8436155c4
+  metadata.gz: 3999f2ac1fedd953c8dfe3461a903b683c9b2260f601ad09430c39677662b22477c0537bc4d5b026abb05c6239a704820c05ee9e39e44f3caa11966221d91bb0
+  data.tar.gz: e32834ea781ca94e0bd2f4d3335b0114edc44eddb68e3c26d5eea3b1cb881753cc3e03fb36504dbcb6f7e0f75aa67597b32faf74315c1868724f75a6753f09e6

data/lib/yeptris/ffi.rb

@@ -240,6 +240,23 @@ module Yeptris
     TAG_NULL = 4
     TAG_TIMESTAMP = 5
 
+    # the schema-descriptor API (issue #238; TODO.restructure/83)
+    DESC_ABI = 1
+    SCHEMA_ERROR = 9
+
+    class DescNode < ::FFI::Struct
+        layout :wire_name, :pointer, :kind, :uint8, :type_tag, :uint8,
+               :flags, :uint16, :child_index, :uint32, :child_count, :uint32,
+               :reserved, :uint32
+      end
+
+    class SchemaColumn < ::FFI::Struct
+        layout :data, :pointer, :capacity, :uint32, :count, :uint32
+    end
+
+    attach_function :yeptris_schema_load,
+                    %i[pointer size_t int pointer uint32 uint32 pointer], :int
+
     SCHEMA_12_CORE = 0
     SCHEMA_11_COMPAT = 1
 

data/lib/yeptris/schema.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Yeptris
+  # The schema-descriptor materialization (issue #238; the C ABI lives
+  # in yeptris/schema.h and docs/schema-abi.md). One native pass fills
+  # typed columns against a caller-compiled descriptor; the
+  # intermediate generic document never exists.
+  module Schema
+    module_function
+
+    KIND = { scalar: 0, sequence: 1, mapping: 2, callback: 3 }.freeze
+    TYPE = { str: 0, int: 1, float: 2, bool: 3, null: 4 }.freeze
+    REQUIRED = 1 << 0
+
+    class Error < Yeptris::Error; end
+    class RequiredMissing < Error; end
+
+    ELEMENT_SIZE = { 0 => 16, 1 => 8, 2 => 8, 3 => 1, 4 => 1 }.freeze # by TYPE value
+
+    # A materialized span: zero-copy off/len into the source plus the
+    # node's byte offset (the CALLBACK escape hatch).
+    Span = Struct.new(:offset, :length, :node_offset) do
+      def bytes_from(source)
+        source.byteslice(offset, length)
+      end
+    end
+
+    # desc: a flat array of node hashes, the C ABI 1:1 —
+    #   { wire_name:, kind:, type:, required:, child_index:, child_count: }
+    # (kind/type symbolic; wire_name nil = the root). Returns one typed
+    # Ruby array per node: Integer/Float/true/false/nil/String for
+    # scalars and sequence elements (document order), Span for
+    # callbacks.
+    def load(source, schema: :core_12, desc:, capacity: 64)
+      source = Yeptris.read_input(source).to_s
+      schema_id = schema == :compat_11 ? FFI::SCHEMA_11_COMPAT : FFI::SCHEMA_12_CORE
+      plans = compile(desc)
+      loop do
+        result = run(source, schema_id, plans, capacity)
+        return result unless result == :grow
+        capacity *= 2
+      end
+    end
+
+    def compile(desc)
+      desc.map do |n|
+        { kind: KIND.fetch(n.fetch(:kind)),
+          type: TYPE.fetch(n[:type] || :str),
+          wire: n[:wire_name],
+          flags: n[:required] ? REQUIRED : 0,
+          child_index: n[:child_index] || 0,
+          child_count: n[:child_count] || 0 }
+      end
+    end
+    private_class_method :compile
+
+    def run(source, schema_id, plans, capacity) # rubocop:disable Metrics/MethodLength
+      n = plans.length
+      desc_buf = ::FFI::MemoryPointer.new(FFI::DescNode, n, true)
+      wires = []
+      plans.each_with_index do |p, i|
+        node = FFI::DescNode.new(desc_buf + i * FFI::DescNode.size)
+        if p[:wire]
+          wires << (wire = ::FFI::MemoryPointer.from_string(p[:wire]))
+          node[:wire_name] = wire
+        end
+        node[:kind] = p[:kind]
+        node[:type_tag] = p[:type]
+        node[:flags] = p[:flags]
+        node[:child_index] = p[:child_index]
+        node[:child_count] = p[:child_count]
+        node[:reserved] = 0
+      end
+      cols_buf = ::FFI::MemoryPointer.new(FFI::SchemaColumn, n, true)
+      data_ptrs = []
+      plans.each_with_index do |p, i|
+        col = FFI::SchemaColumn.new(cols_buf + i * FFI::SchemaColumn.size)
+        elem = ELEMENT_SIZE.fetch(p[:type], 16)
+        data = ::FFI::MemoryPointer.new(elem, capacity, true)
+        data_ptrs << data
+        col[:data] = data
+        col[:capacity] = capacity
+        col[:count] = 0
+      end
+
+      src = ::FFI::MemoryPointer.from_string(source) # NUL-safe copy for the C side
+      st = FFI.yeptris_schema_load(src, source.bytesize, schema_id, desc_buf, n,
+                                   FFI::DESC_ABI, cols_buf)
+      case st
+      when FFI::OK
+        plans.each_with_index.map { |p, i| drain(cols_buf, i, p, source) }
+      when FFI::ERROR_MEMORY
+        :grow
+      when FFI::SCHEMA_ERROR
+        msg = FFI.last_error_message
+        raise RequiredMissing, msg
+      else
+        raise Yeptris::ParseError, FFI.last_error_message
+      end
+    end
+    private_class_method :run
+
+    def drain(cols_buf, i, plan, source)
+      col = FFI::SchemaColumn.new(cols_buf + i * FFI::SchemaColumn.size)
+      count = col[:count]
+      data = col[:data]
+      case plan[:kind]
+      when KIND[:callback]
+        Array.new(count) do |k|
+          off = data.get_uint32(k * 16)
+          len = data.get_uint32(k * 16 + 4)
+          node_off = data.get_uint32(k * 16 + 8)
+          Span.new(off, len, node_off)
+        end
+      else
+        type = plan[:type]
+        Array.new(count) do |k|
+          case type
+          when TYPE[:int] then data.get_int64(k * 8)
+          when TYPE[:float] then data.get_double(k * 8)
+          when TYPE[:bool] then data.get_uchar(k) == 1
+          when TYPE[:null] then nil
+          else
+            off = data.get_uint32(k * 16)
+            len = data.get_uint32(k * 16 + 4)
+            source.byteslice(off, len)
+          end
+        end
+      end
+    end
+    private_class_method :drain
+  end
+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.1.1".freeze
+  VERSION = "0.2.1.2".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
@@ -43,6 +43,13 @@ module Yeptris
   autoload :Materializer, "yeptris/materializer"
   autoload :ValueML, "yeptris/valueml"
   autoload :Psych, "yeptris/psych"
+  autoload :Schema, "yeptris/schema"
+
+  # The safe_load error names, aliased at the top level so consumers
+  # writing rescues need no nesting knowledge (issue #73's naming
+  # note): Yeptris::DisallowedClass is Yeptris::Psych::DisallowedClass.
+  DisallowedClass = Psych::DisallowedClass
+  AliasesError = Psych::AliasesError
 end
 
 # Eager native-library resolution (leptris-ruby lesson): fail at

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.2.1.1
+  version: 0.2.1.2
 platform: aarch64-linux
 authors:
 - Ribose Inc.
@@ -51,6 +51,7 @@ files:
 - lib/yeptris/psych/handler.rb
 - lib/yeptris/psych/parser.rb
 - lib/yeptris/psych/visitors.rb
+- lib/yeptris/schema.rb
 - lib/yeptris/valueml.rb
 - lib/yeptris/yaml.rb
 - libyeptris.so