lutaml-model 0.8.41 → 0.8.43

data/spec/lutaml/model/parse_dispatch_hoist_spec.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#811: the parse path re-resolved per (element × rule) what is
+# static per (attribute/rule, register). These guards pin the hoisting
+# contracts: register-keyed type caching with replacement invalidation,
+# the lock-free child-register resolution, per-rule treatment flags, and
+# the transform dispatch verdicts.
+RSpec.describe "parse-path dispatch hoisting" do
+  describe "Attribute#type register caching" do
+    let(:klass) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :value, :string
+      end
+    end
+
+    it "returns the same resolved class for a repeated register" do
+      attr = klass.attributes[:value]
+      expect(attr.type(:default)).to equal(attr.type(:default))
+    end
+
+    it "does not pin an unregistered register to the thread default" do
+      attr = klass.attributes[:value]
+      expect(attr.type(:nonexistent_register)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "re-resolves when a context is replaced under the same id" do
+      attr = klass.attributes[:value]
+
+      build_context = lambda do |string_type|
+        Lutaml::Model::TypeContext.new(
+          id: :hoist_test,
+          registry: Lutaml::Model::TypeRegistry.new.tap do |r|
+            r.register(:string, string_type)
+          end,
+        )
+      end
+
+      Lutaml::Model::GlobalContext.register_context(
+        build_context.call(Lutaml::Model::Type::String),
+      )
+      expect(attr.type(:hoist_test)).to equal(Lutaml::Model::Type::String)
+      expect(attr.type(:hoist_test)).to equal(Lutaml::Model::Type::String)
+
+      Lutaml::Model::GlobalContext.register_context(
+        build_context.call(Lutaml::Model::Type::Integer),
+      )
+      expect(attr.type(:hoist_test)).to equal(Lutaml::Model::Type::Integer)
+
+      Lutaml::Model::GlobalContext.unregister_context(:hoist_test)
+    end
+  end
+
+  describe "Register.resolve_for_child" do
+    it "caches a nil answer without recomputing" do
+      klass = Class.new(Lutaml::Model::Serializable)
+      expect(Lutaml::Model::Register.resolve_for_child(klass, nil)).to be_nil
+      expect(Lutaml::Model::Register.resolve_for_child(klass, nil)).to be_nil
+    end
+
+    it "resolves the child's own default register over the parent's" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        def self.lutaml_default_register
+          :child_default
+        end
+      end
+      expect(Lutaml::Model::Register.resolve_for_child(klass, :other)).to eq(:child_default)
+      expect(Lutaml::Model::Register.resolve_for_child(klass, nil)).to eq(:child_default)
+    end
+  end
+
+  describe "MappingRule treatment flags" do
+    def rule_with(treat_nil: :nil, treat_empty: :empty, treat_omitted: :nil)
+      Lutaml::Model::MappingRule.new(
+        "name", to: :name,
+                treat_nil: treat_nil, treat_empty: treat_empty,
+                treat_omitted: treat_omitted
+      )
+    end
+
+    it "computes the same answers as the value_map walk" do
+      rule = rule_with(treat_omitted: :omitted, treat_nil: :omitted)
+      expect(rule.treat_omitted?).to be(false)
+      expect(rule.treat_nil?).to be(false)
+      expect(rule.treat_empty?).to be(true)
+
+      expect(rule.treat_omitted?({})).to eq(rule.treat_omitted?)
+      expect(rule.treat_nil?({})).to eq(rule.treat_nil?)
+    end
+
+    it "honors per-call overrides over the precomputed flags" do
+      rule = rule_with
+      expect(rule.treat_omitted?).to be(true)
+      expect(rule.treat_omitted?({ omitted: :omitted })).to be(false)
+      expect(rule.treat_nil?({ nil: :omitted })).to be(false)
+      expect(rule.treat_empty?({ empty: :omitted })).to be(false)
+    end
+  end
+
+  describe "transform dispatch" do
+    let(:base) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :plain, :string
+        attribute :mapped, :string
+      end
+    end
+
+    it "assigns directly for a rule without transformers" do
+      rule = Lutaml::Model::MappingRule.new("mapped", to: :mapped)
+      expect(Lutaml::Model::MappingRule.transform_dispatch(
+               rule, base.attributes[:mapped]
+             )).to be(:assign)
+    end
+
+    it "routes hash transformers through ImportTransformer" do
+      rule = Lutaml::Model::MappingRule.new(
+        "mapped", to: :mapped,
+                  transform: { import: ->(v) { v.to_s.upcase } }
+      )
+      expect(Lutaml::Model::MappingRule.transform_dispatch(
+               rule, base.attributes[:mapped]
+             )).to be(:import)
+    end
+
+    it "applies an import transform through a real round trip" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :shout, :string
+
+        xml do
+          element "doc"
+          map_element "shout", to: :shout,
+                               transform: { import: ->(v) { v.to_s.upcase } }
+        end
+      end
+
+      expect(klass.from_xml("<doc><shout>soft</shout></doc>").shout).to eq("SOFT")
+    end
+  end
+
+  describe "uninitialized defaults are cached" do
+    let(:klass) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :nothing, :string
+      end
+    end
+
+    it "returns the same uninitialized sentinel without re-casting" do
+      attr = klass.attributes[:nothing]
+      expect(attr.default(:default)).to equal(attr.default(:default))
+      expect(attr.default(:default)).to equal(
+        Lutaml::Model::UninitializedClass.instance,
+      )
+    end
+  end
+
+  describe "html-entities decode flag" do
+    it "memoizes per class without changing the answer" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :body, :string
+
+        xml do
+          element "doc"
+          map_element "body", to: :body
+          html_entities
+        end
+      end
+
+      expect(klass.from_xml("<doc><body>a &amp; b</body></doc>").body).to eq("a & b")
+      expect(klass.from_xml("<doc><body>a &amp; b</body></doc>").body).to eq("a & b")
+    end
+  end
+end

data/spec/lutaml/xml/when_attribute_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#88: attribute-value dispatch on a shared wire name.
+# `map_element "component", to: :guidance, when_attribute: { "type" =>
+# "guidance" }` selects only the occurrences whose sibling attribute carries
+# the expected value, and re-emits the discriminator on serialization.
+class WhenAttrComponent < Lutaml::Model::Serializable
+  attribute :text, :string
+
+  xml do
+    element "component"
+    map_element "text", to: :text
+  end
+end
+
+class WhenAttrRequirement < Lutaml::Model::Serializable
+  attribute :guidance, WhenAttrComponent, collection: true
+  attribute :purpose, WhenAttrComponent, collection: true
+  attribute :test_method, WhenAttrComponent, collection: true
+
+  xml do
+    element "requirement"
+    map_element "component", to: :guidance,
+                             when_attribute: { "type" => "guidance" }
+    map_element "component", to: :purpose,
+                             when_attribute: { "type" => "purpose" }
+    map_element "component", to: :test_method,
+                             when_attribute: { type: "test-method" }
+  end
+end
+
+RSpec.describe "when_attribute discriminator mappings" do
+  before do
+    stub_const("WhenAttr::Component", WhenAttrComponent)
+    stub_const("WhenAttr::Requirement", WhenAttrRequirement)
+  end
+
+  let(:xml) do
+    <<~XML
+      <requirement>
+        <component type="guidance"><text>g1</text></component>
+        <component type="purpose"><text>p1</text></component>
+        <component type="guidance"><text>g2</text></component>
+        <component type="test-method"><text>t1</text></component>
+      </requirement>
+    XML
+  end
+
+  it "dispatches occurrences by the discriminator value" do
+    req = WhenAttr::Requirement.from_xml(xml)
+
+    expect(req.guidance.map(&:text)).to eq(%w[g1 g2])
+    expect(req.purpose.map(&:text)).to eq(["p1"])
+    expect(req.test_method.map(&:text)).to eq(["t1"])
+  end
+
+  it "keeps document order within each target attribute" do
+    req = WhenAttr::Requirement.from_xml(xml)
+    expect(req.guidance.map(&:text)).to eq(%w[g1 g2])
+  end
+
+  it "drops occurrences whose discriminator is not covered" do
+    doc = '<requirement><component type="unknown"><text>x</text></component></requirement>'
+    req = WhenAttr::Requirement.from_xml(doc)
+
+    expect(req.guidance).to be_empty
+    expect(req.purpose).to be_empty
+  end
+
+  it "re-emits the discriminator attribute on serialization" do
+    round = WhenAttr::Requirement.from_xml(WhenAttr::Requirement.from_xml(xml).to_xml)
+
+    expect(round.guidance.map(&:text)).to eq(%w[g1 g2])
+    expect(round.purpose.map(&:text)).to eq(["p1"])
+    expect(round.test_method.map(&:text)).to eq(["t1"])
+
+    serialized = WhenAttr::Requirement.from_xml(xml).to_xml
+    expect(serialized).to include('type="guidance"')
+    expect(serialized).to include('type="purpose"')
+    expect(serialized).to include('type="test-method"')
+  end
+
+  it "does not emit a discriminator for ordinary rules" do
+    plain = Class.new(Lutaml::Model::Serializable) do
+      attribute :text, :string
+
+      xml do
+        element "plain"
+        map_element "text", to: :text
+      end
+    end
+
+    expect(plain.from_xml("<plain><text>t</text></plain>").to_xml)
+      .not_to include("type=")
+  end
+
+  it "survives deep_dup of mappings" do
+    mapping = WhenAttr::Requirement.mappings_for(:xml)
+    duped = mapping.deep_dup.mappings.find do |r|
+      r.to == :guidance
+    end
+
+    expect(duped.when_attribute).to eq("type" => "guidance")
+  end
+
+  it "rejects non-string/symbol discriminator shapes" do
+    expect do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :x, :string
+
+        xml do
+          element "x"
+          map_element "x", to: :x, when_attribute: { "type" => 42 }
+        end
+      end
+    end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError, /when_attribute/)
+  end
+
+  it "is rejected on attribute mappings" do
+    expect do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :x, :string
+
+        xml do
+          element "x"
+          map_attribute "x", to: :x, when_attribute: { "type" => "guidance" }
+        end
+      end
+    end.to raise_error(ArgumentError)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.41
+  version: 0.8.43
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-19 00:00:00.000000000 Z
+date: 2026-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1695,6 +1695,7 @@ files:
 - spec/lutaml/model/attribute_form_default_spec.rb
 - spec/lutaml/model/attribute_restriction_spec.rb
 - spec/lutaml/model/attribute_spec.rb
+- spec/lutaml/model/attributes_memo_clear_race_spec.rb
 - spec/lutaml/model/boot_manifest_spec.rb
 - spec/lutaml/model/cached_type_resolver_spec.rb
 - spec/lutaml/model/cardinality_strict_spec.rb
@@ -1737,6 +1738,7 @@ files:
 - spec/lutaml/model/global_register_spec.rb
 - spec/lutaml/model/group_spec.rb
 - spec/lutaml/model/hash/adapter_spec.rb
+- spec/lutaml/model/hydrate_only_mapping_spec.rb
 - spec/lutaml/model/import_registry_spec.rb
 - spec/lutaml/model/included_spec.rb
 - spec/lutaml/model/inheritance_spec.rb
@@ -1765,6 +1767,7 @@ files:
 - spec/lutaml/model/opal_smoke_spec.rb
 - spec/lutaml/model/optimization_spec.rb
 - spec/lutaml/model/ordered_content_spec.rb
+- spec/lutaml/model/parse_dispatch_hoist_spec.rb
 - spec/lutaml/model/parsed_model_mutation_spec.rb
 - spec/lutaml/model/phantom_value_spec.rb
 - spec/lutaml/model/polymorphic_spec.rb
@@ -2003,6 +2006,7 @@ files:
 - spec/lutaml/xml/validate_xml_with_constructs_spec.rb
 - spec/lutaml/xml/validate_xml_with_spec.rb
 - spec/lutaml/xml/w3c_types_spec.rb
+- spec/lutaml/xml/when_attribute_spec.rb
 - spec/lutaml/xml/xml_adapter_spec.rb
 - spec/lutaml/xml/xml_declaration_spec.rb
 - spec/lutaml/xml/xml_element_guard_spec.rb