lutaml-model 0.8.52 → 0.8.53

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92e0193fa58094112522b5a7717aed2f568d77096eb0ae3bc1a246be28c05bf0
-  data.tar.gz: 20dcd124c22c695cc0a8fca65d04422ac84f468515ef153d909e5a6dcf5eac67
+  metadata.gz: 15a10289cc84edab04063cf83dac41f6923500898b0b65e2c72db51421f8a2ad
+  data.tar.gz: 4e6941d70effad354e4798013e27413eb0fd8d8b85643ca5621acb1e009b9247
 SHA512:
-  metadata.gz: 0cc3e71dceb6ae87db00453efbd905de28dc10d528cd38426b29c2c0da1a67d64d41a59095e45a9da1daa97888a4d001c8211b0ad64a3a011ef46949e71206a6
-  data.tar.gz: c444800a986c0e34bc1502fd671f53d7ff4776377d89b62225b857c923f4b97058042094145caf0d0a54db37576bedd546a733e114a444118ff2e13241092d83
+  metadata.gz: 149a8dc04992492d770567285e43fdea303035e93a340554966cf0ff5c844cfb83c03023f214cbc1f50fe3f9e4a20bbce9e540656ed97092876c0b450924e4bd
+  data.tar.gz: 82fc85442bef8b6f0014f03ac10373b03dd99b5be30631f45fbd2e924d02cc6baafbcd75fbb17249c648f9e8711609ba2d5d11494e80f9c6ab734d3cba517bf9

data/.github/workflows/release.yml

@@ -13,9 +13,11 @@ on:
   repository_dispatch:
     types: [ do-release ]
 
+# Least-privilege ceiling for the called rubygems-release.yml: its release job
+# needs contents:write (git tag push) and id-token:write (OIDC Trusted Publishing).
+# packages:write is not required for RubyGems Trusted Publishing.
 permissions:
   contents: write
-  packages: write
   id-token: write
 
 jobs:
@@ -24,5 +26,10 @@ jobs:
     with:
       next_version: ${{ github.event.inputs.next_version }}
     secrets:
-      rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}
+      # OMIT rubygems-api-key: metanorma/ci switches to OIDC Trusted Publishing
+      # when the secret is empty (USE_OIDC = rubygems-api-key == ''). Trusted
+      # Publishing is already configured for lutaml gems on rubygems.org —
+      # do not re-introduce LUTAML_CI_RUBYGEMS_API_KEY here.
+      # pat_token is optional (private-gem checkout + GH Packages). Keep if
+      # the org still uses private deps; drop once pure public.
       pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/docs/_guides/advanced-mapping.adoc

@@ -613,6 +613,14 @@ as `collection: true` when the element repeats. A rule without
 `when_attribute` that shares the name only claims occurrences no
 discriminator rule claimed, so every occurrence is captured exactly once.
 
+On the key-value formats the same coexistence applies to
+`when_attribute` rules sharing one key, regardless of declaration order.
+A rule *without* `when_attribute` is an unconditional claim on the bare
+slot: declaring one replaces prior bare rules on that key — including a
+parent class's rule the subclass remaps to a different attribute — while
+`when_attribute` partitions on the key survive. A partition rule replaces
+only a prior partition with the same target; otherwise it accumulates.
+
 By default an occurrence no rule claims — an uncovered discriminator
 value, or a missing discriminator attribute — is silently dropped.
 Declare `unmatched: :raise` on a discriminator rule to fail the parse

data/lib/lutaml/key_value/mapping.rb

@@ -148,17 +148,40 @@ module Lutaml
           serialize: serialize,
         )
         # lutaml-model#88: rules may share a wire key (when_attribute
-        # partitions) — store per-key arrays, like the XML mapping. A
-        # rule redefining the same target (`to:`) replaces its
-        # predecessor, so subclass and redeclaration overrides keep the
-        # pre-array replace semantics.
+        # partitions) — store per-key arrays, like the XML mapping.
+        # Replacement policy, MECE by rule kind:
+        #   * a bare rule (no when_attribute) replaces prior BARE rules
+        #     on the same wire key — subclass remaps of a key to a
+        #     different attribute (e.g. base `ref → Ref`, subclass
+        #     `ref → text`) must not leave both rules active — while
+        #     when_attribute partitions on the key survive regardless
+        #     of declaration order;
+        #   * a when_attribute rule replaces only a prior partition
+        #     with the same target (`to:`), otherwise it accumulates.
         existing = @mappings[mapping_name]
         if existing.nil?
           @mappings[mapping_name] = [rule]
-        elsif (index = existing.index { |r| r.to == rule.to })
-          existing[index] = rule
+        elsif rule.when_attribute.empty?
+          # Bare claim: prior bare rules on the key are superseded;
+          # partitions survive regardless of declaration order.
+          @mappings[mapping_name] =
+            existing.reject { |r| r.when_attribute.empty? } + [rule]
         else
-          existing << rule
+          index = kv_partition_replace_index(existing, rule)
+          if index
+            existing[index] = rule
+          else
+            existing << rule
+          end
+        end
+      end
+
+      # Index of the prior partition a when_attribute rule replaces
+      # (same target), or nil. Extracted: a block in an elsif condition
+      # mis-binds (the known do/end trap).
+      def kv_partition_replace_index(existing, rule)
+        existing.index do |r|
+          r.to == rule.to && !r.when_attribute.empty?
         end
       end
 

data/lib/lutaml/model/attribute.rb

@@ -161,6 +161,18 @@ module Lutaml
         )
       end
 
+      # Resolution that never materializes deferred model classes:
+      # raises UnknownTypeError for a not-yet-loaded class name.
+      # Mapping-time validation uses this so finalizing one mapping
+      # cannot fire an autoload that re-enters another model file
+      # mid-definition.
+      def loaded_type(context_or_register = nil)
+        return if unresolved_type.nil?
+
+        context = normalize_context(context_or_register)
+        resolver.resolve(unresolved_type, context, materialize: false)
+      end
+
       def type(context_or_register = nil)
         return if unresolved_type.nil?
 

data/lib/lutaml/model/cached_type_resolver.rb

@@ -62,7 +62,9 @@ module Lutaml
       # @param context [TypeContext] The resolution context
       # @return [Class] The resolved type class
       # @raise [UnknownTypeError] If type cannot be resolved
-      def resolve(name, context)
+      def resolve(name, context, materialize: true)
+        return @delegate.resolve(name, context, materialize: false) unless materialize
+
         cache_key = if name.is_a?(Class)
                       [context.id, name]
                     else

data/lib/lutaml/model/serialize/initialization.rb

@@ -204,6 +204,7 @@ module Lutaml
 
           # Clear memoized attribute merge (see .attributes)
           @merged_attributes_cache = nil
+          @instantiate_writers = nil
 
           # Clear per-Attribute type caches (stale entries from GC'd TypeContext objects)
           class_attributes.each_value(&:clear_type_cache)
@@ -368,22 +369,23 @@ module Lutaml
         def instantiate(attrs = {}, register = nil)
           instance = allocate_for_deserialization(register)
           register_id = instance.lutaml_register
-          given = {}
-          attrs.each do |key, value|
-            name = key.to_sym
-            next if name == :lutaml_register
-
-            unless attributes(register_id).key?(name)
-              raise Error, "unknown attribute '#{name}' for #{self}"
-            end
-
-            given[name] = value
-          end
-          attributes(register_id).each do |name, attr|
+          attrs_by = attributes(register_id)
+          writers = instantiate_writers(register_id)
+          given = 0
+          attrs_by.each do |name, attr|
             next if attr.derived?
 
-            if given.key?(name)
-              instance.public_send(:"#{name}=", given[name])
+            # Symbol keys hit directly (native-extension callers);
+            # string keys fall back with one allocated name.
+            key = if attrs.key?(name)
+                    given += 1
+                    name
+                  elsif (str_name = name.to_s) && attrs.key?(str_name)
+                    given += 1
+                    str_name
+                  end
+            if key
+              instance.public_send(writers[name], attrs[key])
             else
               # Absent keys seed their default explicitly, mirroring
               # initialize_attributes: every mapped attribute ends up
@@ -396,13 +398,29 @@ module Lutaml
                       else
                         attr.cast_value(default, register_id)
                       end
-              instance.public_send(:"#{name}=", value)
+              instance.public_send(writers[name], value)
               instance.using_default_for(name)
             end
           end
+          reserved = (attrs.key?(:lutaml_register) ? 1 : 0) +
+            (attrs.key?("lutaml_register") ? 1 : 0)
+          if given + reserved < attrs.size
+            known = attrs_by.keys
+            unknown = attrs.keys.find { |k| !known.include?(k.to_sym) }
+            raise Error, "unknown attribute '#{unknown}' for #{self}"
+          end
           instance
         end
 
+        # Writer method symbols for instantiate, memoized per register
+        # alongside the attribute merge (cleared with it).
+        def instantiate_writers(register_id = nil)
+          (@instantiate_writers ||= {})[register_id] ||= attributes(register_id)
+            .each_with_object({}) do |(name, _attr), memo|
+              memo[name] = :"#{name}="
+            end
+        end
+
         # Define register-specific attribute methods on the class itself.
         #
         # Called once per (class, register) combination. Replaces per-instance

data/lib/lutaml/model/type_resolver.rb

@@ -51,7 +51,11 @@ module Lutaml
       # @example
       #   TypeResolver.resolve(:string, context)  #=> Lutaml::Model::Type::String
       #   TypeResolver.resolve(MyClass, context)  #=> MyClass (pass-through)
-      def self.resolve(name, context)
+      # materialize: false resolves only what the registries know
+      # without const_get — definition-time validation must not fire
+      # autoloads (a pending autoload re-enters the model file being
+      # defined and re-evaluates its mapping on the populated state).
+      def self.resolve(name, context, materialize: true)
         # Apply substitutions even if already a class
         # This is important for type substitution (e.g., Glaze -> RegisterGlaze)
         if name.is_a?(Class)
@@ -79,8 +83,9 @@ module Lutaml
         return apply_substitutions(type, context) if type
 
         # 4. Try Type.const_get for CamelCase type names (e.g., "Decimal" -> Type::Decimal)
-        # This maintains backward compatibility with old Register behavior
-        if name.is_a?(String)
+        # This maintains backward compatibility with old Register behavior.
+        # Skipped for non-materializing resolution: const_get fires autoloads.
+        if materialize && name.is_a?(String)
           begin
             type = Lutaml::Model::Type.const_get(name)
             return apply_substitutions(type, context) if type

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.52"
+    VERSION = "0.8.53"
   end
 end

data/lib/lutaml/xml/mapping.rb

@@ -1112,7 +1112,7 @@ module Lutaml
           next unless target
 
           begin
-            resolved = target.type(Lutaml::Model::Config.default_register)
+            resolved = target.loaded_type(Lutaml::Model::Config.default_register)
           rescue Lutaml::Model::UnknownTypeError
             next
           end

data/lib/lutaml/xml/plan_compiler.rb

@@ -110,6 +110,11 @@ module Lutaml
 
             if rule.attribute?
               return nil unless scalar_type?(attr, register)
+              # Attribute plan rows are local-name keyed; a type-level
+              # namespace makes the attribute (URI, local)-identified
+              # (lutaml-model#744) — the interpretive matcher owns it
+              # until plan rows carry namespace identity.
+              return nil if attr.type_namespace_class(register)
 
               attr_rows << [rule, attr]
               plan_attrs << { name: rule.name.to_s }

data/spec/fixtures/autoload_probe/never_loaded_model.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DeferHost
+  class NeverLoadedModel < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "never"
+      map_element "value", to: :value
+    end
+  end
+end

data/spec/lutaml/key_value/subclass_remap_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# A subclass that remaps a parent wire key onto a different attribute
+# must replace the parent's rule, not accumulate beside it. Pre-#88
+# (hash-keyed by wire name) this was automatic; the #88 array form
+# only replaced on matching `to:`, leaving both rules active and
+# breaking consumers like glossarist's V2::Citation (base maps
+# `ref → Ref`, V2 remaps `ref → text`).
+RSpec.describe "Key-value subclass wire-key remap" do
+  it "replaces the parent rule when the subclass remaps the same key to a different attribute" do
+    base = Class.new(Lutaml::Model::Serializable) do
+      attribute :ref, :string
+      attribute :label, :string
+
+      key_value do
+        map :ref, to: :ref
+      end
+    end
+
+    child = Class.new(base) do
+      key_value do
+        map :ref, to: :label
+      end
+    end
+
+    ref_spellings = [:ref, "ref"].freeze
+    rules = child.mappings_for(:yaml).mappings.select do |r|
+      ref_spellings.include?(r.name)
+    end
+    # Only the child's rule must remain
+    expect(rules.map(&:to)).to eq([:label])
+  end
+
+  it "still accumulates when_attribute partitions of the same wire key" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :a, :string
+      attribute :b, :string
+
+      key_value do
+        map :body, to: :a, when_attribute: { "type" => "a" }
+        map :body, to: :b, when_attribute: { "type" => "b" }
+      end
+    end
+
+    body_spellings = [:body, "body"].freeze
+    expected_targets = %i[a b].freeze
+    rules = klass.mappings_for(:yaml).mappings.select do |r|
+      body_spellings.include?(r.name)
+    end
+    expect(rules.map(&:to)).to match_array(expected_targets)
+  end
+end

data/spec/lutaml/model/deferred_type_no_materialize_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Definition-time attribute-type validation (lutaml-model#296) must
+# resolve types WITHOUT materializing deferred model classes. Eager
+# resolution const_get-fires pending autoloads, which re-enters the
+# model file being defined, re-opens its classes, and re-evaluates an
+# xml mapping block against the already-populated mapping — rejected
+# for map_all_content ("map_all is not allowed ... with map_all").
+RSpec.describe "Definition-time type validation" do
+  # The probe REQUIRES const mechanics (Object.const_set + autoload):
+  # stub_const would define a plain constant and defeat the test.
+  it "leaves a pending autoload unfired while validating a mapping" do
+    probe = Module.new
+    Object.const_set(:DeferHostProbe, probe)
+    probe.autoload(:NeverLoadedModel,
+                   File.expand_path("../../fixtures/autoload_probe/never_loaded_model", __dir__))
+
+    expect do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :ref, "DeferHostProbe::NeverLoadedModel"
+
+        xml do
+          element "doc"
+          map_element "ref", to: :ref
+        end
+      end
+    end.not_to raise_error
+
+    registered = probe.autoload?(:NeverLoadedModel)
+    expect(registered).to be_truthy,
+      "mapping validation materialized the deferred type — it must " \
+      "stay pending for deferred-import resolution"
+  ensure
+    # rubocop:disable-next RSpec/RemoveConst -- unloading the autoload probe
+    Object.send(:remove_const, :DeferHostProbe) if Object.const_defined?(:DeferHostProbe)
+  end
+end

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -64,6 +64,39 @@ RSpec.describe "XML plan fast path" do
     expect(parsed).to be_a(node)
   end
 
+  # lutaml-model#744: attribute plan rows are local-name keyed — a
+  # type-namespaced attribute (xmi:type vs type) must take the
+  # interpretive matcher, or the namespaced value is silently lost.
+  it "opts models with type-namespaced attributes out to the interpretive path" do
+    xmi_ns = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://www.omg.org/spec/XMI/20131001"
+      prefix_default "xmi"
+    end
+    xmi_type = Class.new(Lutaml::Model::Type::String) do
+      xml { namespace xmi_ns }
+    end
+    parameter = Class.new(Lutaml::Model::Serializable) do
+      attribute :xmi_type, xmi_type
+      attribute :classifier_type, :string
+
+      xml do
+        element "ownedParameter"
+        map_attribute "type", to: :xmi_type
+        map_attribute "type", to: :classifier_type
+      end
+    end
+    stub_const("PlanFastPath::NamespacedParam", parameter)
+
+    parsed = parameter.from_xml(
+      '<ownedParameter xmlns:xmi="http://www.omg.org/spec/XMI/20131001" ' \
+      'xmi:type="uml:Parameter" type="EAnone_void"/>',
+    )
+
+    expect(parsed.xmi_type).to eq("uml:Parameter")
+    expect(parsed.classifier_type).to eq("EAnone_void")
+    expect(Lutaml::Xml::PlanCompiler.compile(parameter, :default)).to be_nil
+  end
+
   it "is on by default and can be disabled" do
     expect(Lutaml::Model::Configuration.new.xml_plan_fast_path).to be(true)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.52
+  version: 0.8.53
 platform: ruby
 authors:
 - Ribose Inc.
@@ -977,6 +977,7 @@ files:
 - spec/benchmarks/xml_parsing_benchmark_spec.rb
 - spec/ceramic_spec.rb
 - spec/fixtures/address.rb
+- spec/fixtures/autoload_probe/never_loaded_model.rb
 - spec/fixtures/ceramic.rb
 - spec/fixtures/geolexica_v2_concept.rb
 - spec/fixtures/geolexica_v2_sample.yaml
@@ -1685,6 +1686,7 @@ files:
 - spec/lutaml/jsonld/adapter_spec.rb
 - spec/lutaml/key_value/adapter/toml/teptris_adapter_spec.rb
 - spec/lutaml/key_value/group_instantiate_spec.rb
+- spec/lutaml/key_value/subclass_remap_spec.rb
 - spec/lutaml/key_value/transformation/collection_serializer_spec.rb
 - spec/lutaml/key_value/transformation/rule_compiler_spec.rb
 - spec/lutaml/key_value/transformation/value_serializer_spec.rb
@@ -1729,6 +1731,7 @@ files:
 - spec/lutaml/model/custom_vobject_adapter_spec.rb
 - spec/lutaml/model/default_register_spec.rb
 - spec/lutaml/model/defaults_spec.rb
+- spec/lutaml/model/deferred_type_no_materialize_spec.rb
 - spec/lutaml/model/delegation_spec.rb
 - spec/lutaml/model/derived_attribute_serialization_spec.rb
 - spec/lutaml/model/dynamic_attribute_spec.rb