teptris 0.2.55-s390x-linux → 0.3.0.0-s390x-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caf0fa1b4f608dd75d9b693380d3aadca918363a34772fa856f82e437d0263ae
-  data.tar.gz: dffcd9038b474d0e0794467435fa175d16f7635a54e68213d77e0ecfb331865c
+  metadata.gz: 472a1314831be47d2e80ccdddf7a87af51357dac3ac3aa41dd92d649f82975a2
+  data.tar.gz: 57bcb65db66177d1469c8c1712dc332b2acb828dd36198994ee7440ef2bf5599
 SHA512:
-  metadata.gz: 81982d17e29a8b757ecfe59d3bae4d0abd75c7cbffbe19dcf3fac856047c3383c9730f0ce8031373694200764140814800eaf92c08990722da15e2aada2f52cb
-  data.tar.gz: 5c22c6682428c3c531fc3d1ba4fc47340bf22d5ca5ccdbf8b39e9743404f45ac1c400f351c0375e4e8df99b811b7b4242defaa15f27e156e27b3675cf5a8403b
+  metadata.gz: cb8b0005dfd53387d4b7434c7508889a4bb43541c153f63dc4df9ef6f310bb1987c1cc07e26b74a6ae9881968adf36f2ce2c1c39525f78503270e9b3cc06bff1
+  data.tar.gz: dce82b767d7b40253aa39ddb5d8cb94a6749650bf59d46a1be9d446f1e7fc3334138ce77ca0e86880d09d7888ac12238f4596e1a72db5ad999b85579799a466e

data/ext/teptris_ext/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "mkmf"
 
 # Two modes:
@@ -34,12 +36,8 @@ end
 # On Windows the .so MUST link the ruby DLL import lib — symbols do
 # not resolve at load otherwise.
 win = RUBY_PLATFORM =~ /mingw/
-unless win
-  $LIBS = $LIBS.sub("-lruby", "")
-end
-if RUBY_PLATFORM =~ /darwin/
-  $DLDFLAGS << " -Wl,-undefined,dynamic_lookup"
-end
+$LIBS = $LIBS.sub("-lruby", "") unless win
+$DLDFLAGS << " -Wl,-undefined,dynamic_lookup" if RUBY_PLATFORM =~ /darwin/
 if archive_mode
   # Link the whole archive: every teptris symbol lands inside the ext.
   $LDFLAGS << " #{archive}"
@@ -56,6 +54,6 @@ unless win
   makefile.gsub!(/^LIBRUBYARG_SHARED = .*$/, "LIBRUBYARG_SHARED =")
   makefile.gsub!(/^LIBRUBYARG_STATIC = .*$/, "LIBRUBYARG_STATIC =")
   makefile.gsub!(/^LIBRUBY = .*$/, "LIBRUBY =")
-  makefile.gsub!(/(^|\s)\S*libruby[\w.\/-]*/, "")
+  makefile.gsub!(%r{(^|\s)\S*libruby[\w./-]*}, "")
   File.write("Makefile", makefile)
 end

data/lib/teptris/descriptor.rb

@@ -34,11 +34,12 @@ class Teptris::Descriptor
     # rows).
     # @type var plans: Array[Hash[Symbol, untyped]]
     plans = []
-    # @type var index_of: Hash[Integer, Integer]
+    # @type var index_of: Hash[Object, Integer]
     index_of = {}
+    index_of.compare_by_identity
     collect = lambda do |t|
-      unless index_of.key?(t.object_id)
-        index_of[t.object_id] = plans.length
+      unless index_of.key?(t)
+        index_of[t] = plans.length
         plans << t
       end
       (t[:children] || []).each do |ch|
@@ -53,7 +54,7 @@ class Teptris::Descriptor
     plans.each_with_index do |t, i|
       (t[:children] || []).each_with_index do |ch, j|
         kind = KINDS.fetch(ch[:kind])
-        sub = kind == 3 ? index_of[ch[:plan].object_id] : 0
+        sub = kind == 3 ? index_of[ch[:plan]] : 0
         rows[first_row[i] + j] = [ch[:name].to_s, kind, sub]
       end
     end

data/lib/teptris/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Teptris
   class Error < StandardError; end
 

data/lib/teptris/toml.rb

@@ -1,175 +1,177 @@
+# frozen_string_literal: true
+
 require "date"
 
 require_relative "error"
 
 require_relative "version"
 
-module Teptris
-  # API shape mirrors the tomlib gem: load/dump, String keys, and the
-  # tomlib datetime contract (Time with zone for offset datetimes, local
-  # Time for local datetimes, Date for dates, String "HH:MM:SS" for
-  # local times).
-  module TOML
-    class << self
-      def load(toml)
-        raise ArgumentError, "input must be a String" unless toml.is_a?(String)
-
-        TeptrisExt.load(toml)
+# API shape mirrors the tomlib gem: load/dump, String keys, and the
+# tomlib datetime contract (Time with zone for offset datetimes, local
+# Time for local datetimes, Date for dates, String "HH:MM:SS" for
+# local times).
+module Teptris::TOML
+  class << self
+    def load(toml)
+      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
+    # restricts datetime materialization (raise when a value would
+    # materialize an unpermitted class); datetime_policy :string keeps
+    # every datetime kind as its canonical ISO string instead.
+    def safe_load(toml, permitted_classes: nil, datetime_policy: :native)
+      unless %i[native string].include?(datetime_policy)
+        raise ArgumentError, "datetime_policy must be :native or :string"
       end
 
-      # Safe-load shaped entry point for frameworks: permitted_classes
-      # restricts datetime materialization (raise when a value would
-      # materialize an unpermitted class); datetime_policy :string keeps
-      # every datetime kind as its canonical ISO string instead.
-      def safe_load(toml, permitted_classes: nil, datetime_policy: :native)
-        unless %i[native string].include?(datetime_policy)
-          raise ArgumentError, "datetime_policy must be :native or :string"
-        end
-        # @type var opts: Hash[Symbol, untyped]
-        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
-        load(toml) if opts.empty?
-        TeptrisExt.load(toml, opts)
+      # @type var opts: Hash[Symbol, untyped]
+      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
+      load(toml) if opts.empty?
+      TeptrisExt.load(toml, opts)
+    end
 
-      # Lazy load: returns a wrapper that parses eagerly (one pass)
-      # but materializes host objects only along the paths actually
-      # accessed. Same datetime contract as load; to_h/to_a flatten to
-      # the eager shape.
-      def load_lazy(toml)
-        raise ArgumentError, "input must be a String" unless toml.is_a?(String)
+    # Lazy load: returns a wrapper that parses eagerly (one pass)
+    # but materializes host objects only along the paths actually
+    # accessed. Same datetime contract as load; to_h/to_a flatten to
+    # the eager shape.
+    def load_lazy(toml)
+      raise ArgumentError, "input must be a String" unless toml.is_a?(String)
 
-        TeptrisExt.load_lazy(toml)
-      end
+      TeptrisExt.load_lazy(toml)
+    end
 
-      # Many-small batch path (teptris-ruby#108 ask 3): parse N inputs
-      # in one C call, share the safe_load/datetime_policy options
-      # struct across the batch, return one eager Hash per document.
-      # Same datetime contract as load. A failing document raises
-      # Teptris::ParseError carrying the first failure's line/column.
-      def load_batch(tomls, safe_load: nil, datetime_policy: :native,
-                    threads: 1)
-        _validate_batch!(tomls, safe_load, datetime_policy)
-        opts = _safe_load_opts(safe_load, datetime_policy)
-        return TeptrisExt.load_batch(tomls, opts) if threads <= 1
-
-        # threads > 1: slice across Ruby threads. The C parse releases
-        # the GVL, so parses overlap; materialization serializes on the
-        # GVL. Contiguous slices keep error order deterministic: the
-        # lowest-index failure raises after all threads join.
-        n = tomls.size
-        threads = [threads, n].min
-        return TeptrisExt.load_batch(tomls, opts) if threads <= 1
-        # load_slice releases the GVL once per slice (no per-document
-        # ping-pong) and shares one key cache across its documents.
-        # Repeated objects are dup'd once each HERE: a repeat landing in
-        # two slices would double-lock across threads (the slice-level
-        # guard cannot see across slices); frozen dup'ing is C-side.
-        # @type var seen: Hash[Integer, bool]
-        seen = {}
-        tomls = tomls.map do |s|
-          next s.dup if seen[s.object_id]
-          seen[s.object_id] = true
-          s
-        end
-        per = (n.to_f / threads).ceil
-        results = Array.new(n)
-        # @type var first_error: [Integer, untyped]?
-        first_error = nil
-        mutex = Mutex.new
-        threads.times.map do |ti|
-          Thread.new(ti) do |i|
-            base = i * per
-            slice = tomls[base, per] || []
-            begin
-              loaded = TeptrisExt.load_slice(slice, opts)
-              slice.each_with_index { |_, j| results[base + j] = loaded[j] }
-            rescue StandardError => e
-              mutex.synchronize do
-                first_error ||= [base, e]
-              end
+    # Many-small batch path (teptris-ruby#108 ask 3): parse N inputs
+    # in one C call, share the safe_load/datetime_policy options
+    # struct across the batch, return one eager Hash per document.
+    # Same datetime contract as load. A failing document raises
+    # Teptris::ParseError carrying the first failure's line/column.
+    def load_batch(tomls, safe_load: nil, datetime_policy: :native,
+                   threads: 1)
+      _validate_batch!(tomls, safe_load, datetime_policy)
+      opts = _safe_load_opts(safe_load, datetime_policy)
+      return TeptrisExt.load_batch(tomls, opts) if threads <= 1
+
+      # threads > 1: slice across Ruby threads. The C parse releases
+      # the GVL, so parses overlap; materialization serializes on the
+      # GVL. Contiguous slices keep error order deterministic: the
+      # lowest-index failure raises after all threads join.
+      n = tomls.size
+      threads = [threads, n].min
+      return TeptrisExt.load_batch(tomls, opts) if threads <= 1
+
+      # load_slice releases the GVL once per slice (no per-document
+      # ping-pong) and shares one key cache across its documents.
+      # Repeated objects are dup'd once each HERE: a repeat landing in
+      # two slices would double-lock across threads (the slice-level
+      # guard cannot see across slices); frozen dup'ing is C-side.
+      # compare_by_identity: object-identity keys without the
+      # object_id indirection (same dup-once contract, less aliasing)
+      # @type var seen: Hash[Object, bool]
+      seen = {}
+      seen.compare_by_identity
+      tomls = tomls.map do |s|
+        next s.dup if seen[s]
+
+        seen[s] = true
+        s
+      end
+      per = (n.to_f / threads).ceil
+      results = Array.new(n)
+      # @type var first_error: [Integer, untyped]?
+      first_error = nil
+      mutex = Mutex.new
+      threads.times.map do |ti|
+        Thread.new(ti) do |i|
+          base = i * per
+          slice = tomls[base, per] || []
+          begin
+            loaded = TeptrisExt.load_slice(slice, opts)
+            slice.each_with_index { |_, j| results[base + j] = loaded[j] }
+          rescue StandardError => e
+            mutex.synchronize do
+              first_error ||= [base, e]
             end
           end
-        end.each(&:join)
-        if first_error
-          _, err = first_error
-          raise err
         end
-        results
-      end
-
-      # Lazy twin of load_batch: parse N inputs eagerly, hand back an
-      # Array of Lazy wrappers — materialization happens only on access.
-      # Same per-doc error semantics as load_lazy (first failure raises).
-      def load_lazy_batch(tomls)
-        _validate_batch!(tomls, nil, :native)
-        TeptrisExt.load_lazy_batch(tomls)
+      end.each(&:join)
+      if first_error
+        _, err = first_error
+        raise err
       end
+      results
+    end
 
-      # Many-small path with file paths: read each file, then call
-      # load_batch. Symmetric with load_file's single-doc shape.
-      def load_files(paths, safe_load: nil, datetime_policy: :native)
-        _validate_batch!(paths, safe_load, datetime_policy, kind: :paths)
-        load_batch(paths.map { |p| File.read(p) },
-                   safe_load: safe_load, datetime_policy: datetime_policy)
-      end
+    # Lazy twin of load_batch: parse N inputs eagerly, hand back an
+    # Array of Lazy wrappers — materialization happens only on access.
+    # Same per-doc error semantics as load_lazy (first failure raises).
+    def load_lazy_batch(tomls)
+      _validate_batch!(tomls, nil, :native)
+      TeptrisExt.load_lazy_batch(tomls)
+    end
 
-      # One-pass schema materialization over a compiled
-      # Teptris::Descriptor: unplanned keys are never materialized
-      # (teptris#46).
-      def load_schema(toml, descriptor)
-        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
+    # Many-small path with file paths: read each file, then call
+    # load_batch. Symmetric with load_file's single-doc shape.
+    def load_files(paths, safe_load: nil, datetime_policy: :native)
+      _validate_batch!(paths, safe_load, datetime_policy, kind: :paths)
+      load_batch(paths.map { |p| File.read(p) },
+                 safe_load: safe_load, datetime_policy: datetime_policy)
+    end
 
-      def engine_version
-        TeptrisExt.engine_version
+    # One-pass schema materialization over a compiled
+    # Teptris::Descriptor: unplanned keys are never materialized
+    # (teptris#46).
+    def load_schema(toml, descriptor)
+      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
 
-      public
+    def engine_version
+      TeptrisExt.engine_version
+    end
 
-      def load_file(path)
-        load(File.read(path))
-      end
+    def load_file(path)
+      load(File.read(path))
+    end
 
-      def dump(obj)
-        TeptrisExt.dump(obj)
-      end
+    def dump(obj)
+      TeptrisExt.dump(obj)
+    end
 
-      private
+    private
 
-      def _validate_batch!(input, safe_load, datetime_policy, kind: :strings)
-        unless input.is_a?(Array)
-          raise ArgumentError, "expected Array of #{kind}, got #{input.class}"
-        end
-        if !safe_load.nil? && !safe_load.is_a?(Array) && !safe_load.is_a?(Symbol)
-          raise ArgumentError, "safe_load must be nil, an Array, or a Symbol"
-        end
-        unless %i[native string].include?(datetime_policy)
-          raise ArgumentError, "datetime_policy must be :native or :string"
-        end
+    def _validate_batch!(input, safe_load, datetime_policy, kind: :strings)
+      raise ArgumentError, "expected Array of #{kind}, got #{input.class}" unless input.is_a?(Array)
+      if !safe_load.nil? && !safe_load.is_a?(Array) && !safe_load.is_a?(Symbol)
+        raise ArgumentError, "safe_load must be nil, an Array, or a Symbol"
       end
+      return if %i[native string].include?(datetime_policy)
 
-      def _safe_load_opts(safe_load, datetime_policy)
-        # @type var opts: Hash[Symbol, untyped]
-        opts = {}
-        opts[:string_datetimes] = true if datetime_policy == :string
-        if safe_load && datetime_policy == :native
-          permitted = Array(safe_load) + [:__scalar]
-          opts[:forbid_time] = true unless permitted.include?(Time)
-          opts[:forbid_date] = true unless permitted.include?(Date)
-        end
-        opts.empty? ? nil : opts
+      raise ArgumentError, "datetime_policy must be :native or :string"
+    end
+
+    def _safe_load_opts(safe_load, datetime_policy)
+      # @type var opts: Hash[Symbol, untyped]
+      opts = {}
+      opts[:string_datetimes] = true if datetime_policy == :string
+      if safe_load && datetime_policy == :native
+        permitted = Array(safe_load) + [:__scalar]
+        opts[:forbid_time] = true unless permitted.include?(Time)
+        opts[:forbid_date] = true unless permitted.include?(Date)
       end
+      opts.empty? ? nil : opts
     end
   end
 end

data/lib/teptris/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Teptris
-  VERSION = "0.2.55"
+  VERSION = "0.3.0.0"
 end

data/lib/teptris.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 
 require_relative "teptris/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.2.55
+  version: 0.3.0.0
 platform: s390x-linux
 authors:
 - teptris contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies: []
 description: A native C extension over libteptris, a C99 TOML 1.1 parser/emitter.
   API shape mirrors the tomlib gem.