teptris 0.1.0 → 0.2.36

data/lib/teptris/toml.rb

@@ -1,7 +1,7 @@
 require "date"
 
 require_relative "error"
-require_relative "lib"
+
 require_relative "version"
 
 module Teptris
@@ -12,7 +12,9 @@ module Teptris
   module TOML
     class << self
       def load(toml)
-        parse_and_materialize(toml, 0, nil)
+        raise ArgumentError, "input must be a String" unless toml.is_a?(String)
+
+        TeptrisExt.load(toml)
       end
 
       # Safe-load shaped entry point for frameworks: permitted_classes
@@ -23,46 +25,31 @@ module Teptris
         unless %i[native string].include?(datetime_policy)
           raise ArgumentError, "datetime_policy must be :native or :string"
         end
-        mode = datetime_policy == :string ? 1 : 0
-        permitted = permitted_classes && Set.new(permitted_classes)
-        if permitted && mode.zero?
-          permitted << String # TOML scalars are always materialized
+        opts = {}
+        opts[:string_datetimes] = true if datetime_policy == :string
+        if permitted_classes && datetime_policy == :native
+          permitted = permitted_classes + [:__scalar]
+          opts[:forbid_time] = true unless permitted.include?(Time)
+          opts[:forbid_date] = true unless permitted.include?(Date)
         end
-        parse_and_materialize(toml, mode, permitted)
+        load(toml) if opts.empty?
+        TeptrisExt.load(toml, opts)
       end
 
-      # Reserved: fused descriptor materialization, the same descriptor
-      # shape as leptris/yeptris#238 — see docs/DESCRIPTOR_ABI.md. The
-      # entry point exists so frameworks can code against it today; the
-      # fused native pass lands with the co-designed ABI.
+      # One-pass schema materialization over a compiled
+      # Teptris::Descriptor: unplanned keys are never materialized
+      # (teptris#46).
       def load_schema(toml, descriptor)
-        raise Error,
-              "descriptor materialization lands with the co-designed " \
-              "ABI (leptris/yeptris#238); entry point is reserved — " \
-              "see docs/DESCRIPTOR_ABI.md (descriptor #{descriptor.class})"
+        unless descriptor.is_a?(Teptris::Descriptor)
+          raise ArgumentError,
+                "descriptor must be a Teptris::Descriptor (use " \
+                "Teptris::Descriptor.build), got #{descriptor.class}"
+        end
+        descriptor.walk(toml)
       end
 
-      private
-
-      def parse_and_materialize(toml, mode, permitted)
-        raise ArgumentError, "input must be a String" unless toml.is_a?(String)
-
-        data = FFI::MemoryPointer.from_string(toml)
-        docp = FFI::MemoryPointer.new(:pointer)
-        st = Lib.teptris_parse(data, toml.bytesize, nil, docp)
-        handle = docp.read_pointer
-        if st != Teptris::TEPTRIS_OK
-          raise build_parse_error(handle)
-        end
-        begin
-          @mode = mode
-          @permitted = permitted
-          load_flat(handle)
-        ensure
-          @mode = nil
-          @permitted = nil
-          Lib.teptris_document_free(handle)
-        end
+      def engine_version
+        TeptrisExt.engine_version
       end
 
       public
@@ -72,241 +59,7 @@ module Teptris
       end
 
       def dump(obj)
-        raise ArgumentError, "cannot dump #{obj.class}" unless obj.is_a?(Hash)
-
-        out = +""
-        emit_table(obj, out, nil)
-        out
-      end
-
-      private
-
-      def build_parse_error(handle)
-        line = 0
-        column = 0
-        msg = "parse failed"
-        unless handle.null?
-          es = Lib::ErrorStruct.new(Lib.teptris_document_error(handle))
-          line = es[:line]
-          column = es[:column]
-          msg = es[:message]
-        end
-        ParseError.new(msg, line, column)
-      end
-
-      # One-bulk-drain load: the C side flattens the whole tree in a
-      # single crossing; this decoder walks the typed flat buffer.
-      FLAT_TABLE = 0x01
-      FLAT_ARRAY = 0x02
-      FLAT_STRING = 0x03
-      FLAT_INT = 0x04
-      FLAT_FLOAT = 0x05
-      FLAT_FALSE = 0x06
-      FLAT_TRUE = 0x07
-      FLAT_DT = 0x08 # ..0x0B: offset, local-datetime, date, local-time
-
-      def load_flat(handle)
-        bufp = FFI::MemoryPointer.new(:pointer)
-        lenp = FFI::MemoryPointer.new(:size_t)
-        st = Lib.teptris_document_flatten(handle, bufp, lenp)
-        raise Error, "flatten failed" unless st == Teptris::TEPTRIS_OK
-
-        buf = bufp.read_pointer
-        begin
-          data = buf.get_bytes(0, lenp.read_uint64)
-          value, = decode_flat(data, 0)
-          value
-        ensure
-          Lib.teptris_flatten_free(buf)
-        end
-      end
-
-      def decode_flat(d, pos)
-        case d.getbyte(pos)
-        when FLAT_TABLE
-          n = d.unpack1("L<", offset: pos + 1)
-          pos += 5
-          h = {}
-          n.times do
-            kl = d.unpack1("L<", offset: pos)
-            pos += 4
-            k = d.byteslice(pos, kl).force_encoding(Encoding::UTF_8)
-            pos += kl
-            v, pos = decode_flat(d, pos)
-            h[k] = v
-          end
-          [h, pos]
-        when FLAT_ARRAY
-          n = d.unpack1("L<", offset: pos + 1)
-          pos += 5
-          a = Array.new(n)
-          n.times do |i|
-            a[i], pos = decode_flat(d, pos)
-          end
-          [a, pos]
-        when FLAT_STRING
-          l = d.unpack1("L<", offset: pos + 1)
-          pos += 5
-          [d.byteslice(pos, l).force_encoding(Encoding::UTF_8), pos + l]
-        when FLAT_INT
-          [d.unpack1("q<", offset: pos + 1), pos + 9]
-        when FLAT_FLOAT
-          [d.unpack1("E", offset: pos + 1), pos + 9]
-        when FLAT_FALSE then [false, pos + 1]
-        when FLAT_TRUE then [true, pos + 1]
-        when FLAT_DT, FLAT_DT + 1, FLAT_DT + 2, FLAT_DT + 3
-          kind = d.getbyte(pos)
-          year = d.unpack1("q<", offset: pos + 1)
-          mon = d.getbyte(pos + 9)
-          day = d.getbyte(pos + 10)
-          hour = d.getbyte(pos + 11)
-          min = d.getbyte(pos + 12)
-          sec = d.getbyte(pos + 13)
-          nsec = d.unpack1("L<", offset: pos + 14)
-          off = d.unpack1("q<", offset: pos + 18)
-          [flat_datetime(kind, year, mon, day, hour, min, sec, nsec, off),
-           pos + 26]
-        else
-          raise Error, "corrupt flat buffer at #{pos}"
-        end
-      end
-
-      def flat_datetime(kind, y, mon, day, hour, min, sec, nsec, off)
-        return flat_datetime_string(kind, y, mon, day, hour, min, sec, nsec, off) if @mode == 1
-
-        rational = Rational(sec * 1_000_000_000 + nsec, 1_000_000_000)
-        case kind
-        when FLAT_DT
-          check_permitted!(Time)
-          Time.new(y, mon, day, hour, min, rational, off)
-        when FLAT_DT + 1
-          check_permitted!(Time)
-          Time.local(y, mon, day, hour, min, rational)
-        when FLAT_DT + 2
-          check_permitted!(Date)
-          Date.new(y, mon, day)
-        else
-          s = format("%02d:%02d:%02d", hour, min, sec)
-          s << "." << format("%09d", nsec).sub(/0+\z/, "") if nsec.positive?
-          s
-        end
-      end
-
-      def check_permitted!(klass)
-        permitted = @permitted
-        return if permitted.nil? || permitted.include?(klass)
-
-        raise Error,
-              "value materializes #{klass}, which is not in " \
-              "permitted_classes (use datetime_policy: :string to keep " \
-              "datetimes as strings)"
-      end
-
-      def flat_datetime_string(kind, y, mon, day, hour, min, sec, nsec, off)
-        case kind
-        when FLAT_DT + 2 then return format("%04d-%02d-%02d", y, mon, day)
-        when FLAT_DT + 3 then s = +""
-        else s = +(format("%04d-%02d-%02dT", y, mon, day))
-        end
-        s << format("%02d:%02d:%02d", hour, min, sec)
-        if nsec.positive?
-          s << "." << format("%09d", nsec).sub(/0+\z/, "")
-        end
-        case kind
-        when FLAT_DT
-          off.zero? ? s << "Z" : s << format("%+03d:%02d", off / 3600, (off % 3600).abs / 60)
-        end
-        s
-      end
-
-      # ---- dump -----------------------------------------------------------
-
-      def emit_table(hash, out, prefix)
-        hash.each do |k, v|
-          next if table?(v) || aot?(v)
-
-          out << emit_key(k) << " = " << emit_value(v) << "\n"
-        end
-        hash.each do |k, v|
-          next unless table?(v) || aot?(v)
-
-          path = prefix ? "#{prefix}.#{emit_key(k)}" : emit_key(k)
-          if aot?(v)
-            v.each do |item|
-              out << "[[" << path << "]]\n"
-              emit_table(item, out, path)
-            end
-          else
-            out << "[" << path << "]\n"
-            emit_table(v, out, path)
-          end
-        end
-      end
-
-      def table?(v)
-        v.is_a?(Hash)
-      end
-
-      def aot?(v)
-        v.is_a?(Array) && !v.empty? && v.all? { |e| e.is_a?(Hash) }
-      end
-
-      def emit_key(k)
-        k = k.to_s
-        if /\A[A-Za-z0-9_-]+\z/.match?(k)
-          k
-        elsif !k.include?("'") && !k.each_char.any? { |c| c.ord < 0x20 }
-          "'#{k}'"
-        else
-          "\"#{escape_basic(k)}\""
-        end
-      end
-
-      BASIC_ESCAPES = {
-        "\\" => "\\\\\\\\", # \ -> \\
-        "\"" => "\\\"", "\b" => "\\b", "\f" => "\\f",
-        "\n" => "\\n", "\r" => "\\r", "\t" => "\\t"
-      }.freeze
-
-      def escape_basic(s)
-        s.gsub(/[\\\"\b\f\n\r\t]/) { |c| BASIC_ESCAPES[c] }
-      end
-
-      def emit_value(v)
-        case v
-        when String
-          if !v.include?("'") && !v.each_char.any? { |c| c.ord < 0x20 }
-            "'#{v}'"
-          else
-            "\"#{escape_basic(v)}\""
-          end
-        when Integer then v.to_s
-        when Float
-          return v.to_s if v.finite?
-
-          v.nan? ? "nan" : (v.positive? ? "inf" : "-inf")
-        when TrueClass then "true"
-        when FalseClass then "false"
-        when Time
-          base = v.strftime("%Y-%m-%dT%H:%M:%S")
-          frac = v.strftime("%N").sub(/0+\z/, "")
-          base << "." << frac unless frac.empty?
-          base << tz(v)
-        when Date then v.iso8601
-        when Array then "[#{v.map { |e| emit_value(e) }.join(', ')}]"
-        when Hash
-          "{#{v.map { |k, e| "#{emit_key(k)} = #{emit_value(e)}" }.join(', ')}}"
-        else raise Error, "cannot dump #{v.class}"
-        end
-      end
-
-      def tz(time)
-        off = time.utc_offset
-        return "Z" if off.zero?
-
-        sign = off.negative? ? "-" : "+"
-        off = -off if off.negative?
-        format("%s%02d:%02d", sign, off / 3600, (off % 3600) / 60)
+        TeptrisExt.dump(obj)
       end
     end
   end

data/lib/teptris/version.rb

@@ -1,3 +1,3 @@
 module Teptris
-  VERSION = "0.1.0"
+  VERSION = "0.2.36"
 end

data/lib/teptris.rb

@@ -1,10 +1,26 @@
-require "set"
+require "date"
 
 require_relative "teptris/version"
 require_relative "teptris/error"
-require_relative "teptris/lib"
+require_relative "teptris/descriptor"
 require_relative "teptris/toml"
 
+# Windows ucrt rubies name their DLL per minor (x64-ucrt-ruby330.dll), so
+# the mingw gems ship one extension per ruby minor beside a shared
+# libteptris.dll (nokogiri's fat-gem layout). The native extension IS the
+# binding — no fallback, ever.
+begin
+  if RUBY_PLATFORM =~ /mingw/
+    require "teptris/#{RUBY_VERSION[/\A\d+\.\d+/]}/teptris_ext"
+  else
+    require "teptris_ext"
+  end
+rescue LoadError
+  raise LoadError,
+        "teptris native extension not available for #{RUBY_PLATFORM} " \
+        "ruby #{RUBY_VERSION} (no fallback by design)"
+end
+
 module Teptris
   TEPTRIS_OK = 0
 end

metadata

@@ -1,39 +1,58 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.36
 platform: ruby
 authors:
 - teptris contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: ffi
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-description: An FFI binding over libteptris, a C11 TOML 1.0 parser/emitter. API shape
-  mirrors the tomlib gem.
+date: 2026-09-18 00:00:00.000000000 Z
+dependencies: []
+description: A native C extension over libteptris, a C11 TOML 1.1 parser/emitter.
+  API shape mirrors the tomlib gem.
 email:
 executables: []
-extensions: []
+extensions:
+- ext/teptris_ext/extconf.rb
 extra_rdoc_files: []
 files:
+- ext/teptris_ext/engine/LICENSE.md
+- ext/teptris_ext/engine/src/include/teptris/plan.h
+- ext/teptris_ext/engine/src/include/teptris/teptris.h
+- ext/teptris_ext/engine/src/include/teptris/version.h
+- ext/teptris_ext/engine/src/teptris/api.c
+- ext/teptris_ext/engine/src/teptris/build.c
+- ext/teptris_ext/engine/src/teptris/common/chartype.c
+- ext/teptris_ext/engine/src/teptris/common/chartype.h
+- ext/teptris_ext/engine/src/teptris/common/ryu/common.h
+- ext/teptris_ext/engine/src/teptris/common/ryu/d2s.c
+- ext/teptris_ext/engine/src/teptris/common/ryu/d2s_full_table.h
+- ext/teptris_ext/engine/src/teptris/common/ryu/d2s_intrinsics.h
+- ext/teptris_ext/engine/src/teptris/common/ryu/digit_table.h
+- ext/teptris_ext/engine/src/teptris/common/ryu/ryu_d2s.h
+- ext/teptris_ext/engine/src/teptris/common/ryu/ryu_parse.h
+- ext/teptris_ext/engine/src/teptris/common/ryu/s2d.c
+- ext/teptris_ext/engine/src/teptris/common/simd.h
+- ext/teptris_ext/engine/src/teptris/dom/dom.c
+- ext/teptris_ext/engine/src/teptris/dom/dom.h
+- ext/teptris_ext/engine/src/teptris/emit/emitter.c
+- ext/teptris_ext/engine/src/teptris/emit/emitter.h
+- ext/teptris_ext/engine/src/teptris/memory/arena.c
+- ext/teptris_ext/engine/src/teptris/memory/arena.h
+- ext/teptris_ext/engine/src/teptris/parse/datetime.c
+- ext/teptris_ext/engine/src/teptris/parse/keys.c
+- ext/teptris_ext/engine/src/teptris/parse/parse.h
+- ext/teptris_ext/engine/src/teptris/parse/parser.c
+- ext/teptris_ext/engine/src/teptris/parse/scalars.c
+- ext/teptris_ext/engine/src/teptris/plan/plan.c
+- ext/teptris_ext/engine/src/teptris/version.c
+- ext/teptris_ext/extconf.rb
+- ext/teptris_ext/materialize.c
 - lib/teptris.rb
+- lib/teptris/descriptor.rb
 - lib/teptris/error.rb
-- lib/teptris/lib.rb
 - lib/teptris/toml.rb
 - lib/teptris/version.rb
 homepage: https://github.com/leptris/teptris-ruby
@@ -58,5 +77,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: TOML for Ruby at libleptris speed (FFI, no C extension)
+summary: TOML for Ruby at libteptris speed (native C extension)
 test_files: []

data/lib/teptris/lib.rb

@@ -1,81 +0,0 @@
-require "ffi"
-
-module Teptris
-  # Loads the shared libteptris: TEPTRIS_LIB_PATH env, vendored
-  # lib/platform/<tag>/, the sibling C checkout's build tree, then the
-  # system paths (yeptris-ruby resolution chain).
-  module Lib
-    extend FFI::Library
-
-    NAMES = %w[libteptris.dylib libteptris.so libteptris.dll].freeze
-
-    def self.candidates
-      out = []
-      out << ENV["TEPTRIS_LIB_PATH"] if ENV["TEPTRIS_LIB_PATH"]
-      out.concat(Dir[File.expand_path("../libteptris.*", __dir__)])
-      NAMES.each do |n|
-        %w[build build-release build-shared build-bench].each do |b|
-          out << File.expand_path("../../teptris/#{b}/src/#{n}", __dir__)
-        end
-        out << n
-      end
-      out.compact
-    end
-
-    loaded = nil
-    candidates.each do |c|
-      begin
-        ffi_lib c
-        loaded = c
-        break
-      rescue LoadError
-        next
-      end
-    end
-    raise Error, "libteptris not found (set TEPTRIS_LIB_PATH)" unless loaded
-    LIBRARY_PATH = loaded
-
-    typedef :pointer, :doc
-    typedef :pointer, :node
-
-    attach_function :teptris_parse, [:pointer, :size_t, :pointer, :pointer], :int
-    attach_function :teptris_document_free, [:doc], :void
-    attach_function :teptris_document_error, [:doc], :pointer
-    attach_function :teptris_document_root, [:doc], :node
-    attach_function :teptris_document_emit, [:doc, :pointer, :pointer], :int
-    attach_function :teptris_node_kind, [:node], :int
-    attach_function :teptris_node_string, [:node, :pointer], :int
-    attach_function :teptris_node_integer, [:node, :pointer], :int
-    attach_function :teptris_node_float, [:node, :pointer], :int
-    attach_function :teptris_node_boolean, [:node, :pointer], :int
-    attach_function :teptris_node_datetime, [:node, :pointer], :int
-    attach_function :teptris_node_array_length, [:node], :size_t
-    attach_function :teptris_node_array_at, [:node, :size_t], :node
-    attach_function :teptris_node_table_length, [:node], :size_t
-    attach_function :teptris_node_table_at, [:node, :size_t, :pointer], :node
-    attach_function :teptris_document_flatten, [:doc, :pointer, :pointer], :int
-    attach_function :teptris_flatten_free, [:pointer], :void
-
-    class ErrorStruct < FFI::Struct
-      layout :status, :int, :line, :size_t, :column, :size_t, :message, :string
-    end
-
-    class ViewStruct < FFI::Struct
-      layout :ptr, :pointer, :len, :size_t
-    end
-
-    class DateTimeStruct < FFI::Struct
-      layout :year, :int32,
-             :month, :uint8, :day, :uint8,
-             :hour, :uint8, :minute, :uint8, :second, :uint8,
-             :_pad, [:uint8, 3],
-             :nanosecond, :uint32, :offset_seconds, :int32
-    end
-  end
-
-  KIND = {
-    string: 0, integer: 1, float: 2, boolean: 3,
-    datetime: 4, datetime_local: 5, date_local: 6, time_local: 7,
-    array: 8, table: 9
-  }.freeze
-end