teptris 0.2.54-powerpc64le-linux → 0.2.56-powerpc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f06803f154a5072fe10def850b80baec9295a4f4276a6126385cd08d69977b2
-  data.tar.gz: 4444c30d22d28fb3a8be5509146223706cfb0a3c5ff60b3b15a2997b8c15107a
+  metadata.gz: 32b39ffbd30932eca5a224111eba8d0bafb2caee197d34d89bbfbfe564ee9842
+  data.tar.gz: 37b2de3ec0726b22136ead32e4977cfee8f05d168e5d3238c887f25b3af1da81
 SHA512:
-  metadata.gz: c3423559c0cf6e7b8e80b24584f922c7afb37cc9aa898e5f1777caeede8266192f0a1a29d97affa7df928fc647569ad71009ab4616159f1a98a86baaed0c1dc4
-  data.tar.gz: e073c1c5671c6a3c142284ceed2c0d2c051f2284fc189e0e84d2a2a8af04e51b74036b7b47b3d1d7c4910ba76c337369a70ca8a7a94a883257b6ce7fe8d8957b
+  metadata.gz: 0f66e8df86cb3d7b8a72228ccc7523c43ddc00a541fb7a32d3601fb4bca87129d485880d6b921b6d2208e801acf22fa28cfa4547c16609fef2bd232df130cb05
+  data.tar.gz: c65385e861e11cac016952efa0fa56b232277e0e2ec89d53413025db083532883ed7651aaa9880a7db2148b9f5516f7ad467fabe1e0be766f87706e7ddb2c96c

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.54"
+  VERSION = "0.2.56"
 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.54
+  version: 0.2.56
 platform: powerpc64le-linux
 authors:
 - teptris contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-04 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.
@@ -63,7 +63,12 @@ files:
 homepage: https://github.com/leptris/teptris-ruby
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/leptris/teptris-ruby/issues
+  changelog_uri: https://github.com/leptris/teptris-ruby/releases
+  documentation_uri: https://leptris.github.io/docs/teptris-ruby
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/leptris/teptris-ruby
 post_install_message:
 rdoc_options: []
 require_paths: