lutaml-model 0.8.35 → 0.8.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a5f36f080c15bb2639142a36b424853d26458732c867963dbf7a99d6a1cd189
-  data.tar.gz: 3159ba755e2cc317e5e9b3785b2be1cffb08e424b2bd792bca34f20c853d25be
+  metadata.gz: 13023a5add888c4affa15d1e7c025548e329b0aad8112582550be7cff794524a
+  data.tar.gz: 7393786a16da4f06d7962f7395edab78b5985ab1820c98da8b95f66f669be99d
 SHA512:
-  metadata.gz: e83080b05e3277310d103e84c5f63fda7e963e25bb1cdc764934a1d931e388f212b51f97c5a02182966b3e376a97d00fc30fa396568a644100b5745064d1fd1a
-  data.tar.gz: f59d08e3915dacf3a7da3c0bfbc2e9b300cb7c66177c6dd4455870349fc4f2cb892d8d34a1028b74f2660b87e21980b44a4e941329fcf8a69687fde9a7d336f0
+  metadata.gz: 03be6773d23935e26c6593d2c966f5063af4840142f988c6db534517b26b7889adc15c11c5d5280b181b9b19e35a971bbbc889ce673d63a750385e5b392d60b7
+  data.tar.gz: 656f73aab6fe55e9dbe8337a8c6ec76fae5c2cadfade74bdd30500d3ea16105cdf3de1ebce9d837b4ddd3c6851e84ac7b5b7a7f40f2729d79827014e9d0a0b9e

data/lib/lutaml/model/attribute.rb

@@ -436,18 +436,31 @@ module Lutaml
       end
 
       def cast_element(value, register)
-        # Resolve first: an undeclared type has to raise UnknownTypeError even
-        # when the value carries nothing, the way it did before the guard
-        # below existed.
-        resolved_type = type(register)
+        # Resolve first: an undeclared type has to raise UnknownTypeError
+        # even for a nil value (the 0.8.33 behavior).
+        type(register)
+
+        return value if Utils.uninitialized?(value)
+
+        # nil reaches the type's cast — the long-shipped contract
+        # ST_OnOff-style types depend on (absent attribute -> cast(nil)
+        # -> false; lutaml-model#795). What nil must NOT do is
+        # manufacture a typed INSTANCE from nothing: that is the
+        # phantom #793 removed, suppressed by the post-check below.
+        if value.nil?
+          result = cast_element_present(value, register)
+          return result if result.nil?
+          return nil if result.is_a?(Lutaml::Model::Type::Value) ||
+            result.is_a?(Lutaml::Model::Serialize)
 
-        # Casting is for data. Every built-in type already hands nil and the
-        # uninitialized sentinel straight back, so this changes nothing for
-        # them. A type with its own `self.cast` returns a real instance
-        # instead, and that instance becomes a value nobody wrote — a phantom
-        # element in the document, or a one-item collection the source never
-        # contained. `cast` below guards the format entry point the same way.
-        return value if no_data?(value)
+          return result
+        end
+
+        cast_element_present(value, register)
+      end
+
+      def cast_element_present(value, register)
+        resolved_type = type(register)
 
         return cast_union(value, nil, register) if union?
         return resolved_type.new(value) if value.is_a?(::Hash) && !hash_type?
@@ -785,14 +798,25 @@ instance_object = nil)
       end
 
       def cast(value, format, register, options = {})
-        # Same rule as cast_element, for the format entry point. from_json /
-        # from_yaml / from_toml / from_hash reach a missing key as nil, and a
-        # type with its own `self.cast` turns that nil into an instance the
-        # document never carried. Unlike cast_element this returns before
-        # resolving the type: resolution here depends on the format options
-        # below, and an undeclared type still raises through cast_element.
-        return value if no_data?(value)
+        # Sentinel: never a cast input. nil flows on — absent values
+        # reach the type's cast (ST_OnOff booleans, #795); a cast that
+        # manufactures a typed instance from nothing is the phantom
+        # #793 removed, suppressed here as in cast_element.
+        return value if Utils.uninitialized?(value)
+
+        if value.nil?
+          result = cast_present(value, format, register, options)
+          return result if result.nil?
+          return nil if result.is_a?(Lutaml::Model::Type::Value) ||
+            result.is_a?(Lutaml::Model::Serialize)
+
+          return result
+        end
+
+        cast_present(value, format, register, options)
+      end
 
+      def cast_present(value, format, register, options = {})
         # Namespace-aware type resolution: use type_with_namespace if namespace_uri provided
         namespace_uri = options[:namespace_uri]
         resolved_type = if options[:resolved_type]

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.35"
+    VERSION = "0.8.36"
   end
 end

data/lib/lutaml/xml/model_transform.rb

@@ -402,7 +402,7 @@ instance_is_serialize = nil)
         # dup: XmlElement#order hands back a frozen cache shared with the
         # DOM. The model's copy has to stay mutable so callers can maintain
         # element_order themselves.
-        instance.element_order = doc.root.order.dup
+        instance.element_order = doc.root.order
         if instance_is_serialize && doc.root.is_a?(::Lutaml::Xml::XmlElement)
           instance.attribute_order = doc.root.attribute_order
         end

data/spec/lutaml/model/absent_value_contracts_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# The 0.8.33 parse contracts restored after #795: a custom type's cast
+# sees an absent attribute's nil (ST_OnOff booleans — an absent flag is
+# semantically false), and the parsed element_order array is frozen
+# (consumers build thaw-on-demand helpers on that).
+RSpec.describe "absent-value and order contracts" do
+  before do
+    stub_const("OnOff", Class.new(Lutaml::Model::Type::Boolean) do
+      def self.cast(value, _options = {})
+        return false if value.nil?
+
+        super
+      end
+    end)
+
+    stub_const("Doc", Class.new(Lutaml::Model::Serializable) do
+      attribute :flag, OnOff
+      xml do
+        element "doc"
+        map_attribute "flag", to: :flag
+      end
+    end)
+  end
+
+  it "casts an absent attribute through the type (nil -> false)" do
+    expect(Doc.from_xml("<doc/>").flag).to be(false)
+  end
+
+  it "still casts a present attribute" do
+    expect(Doc.from_xml('<doc flag="0"/>').flag).to be(false)
+    expect(Doc.from_xml('<doc flag="1"/>').flag).to be(true)
+  end
+
+  it "hands the parsed element_order back frozen" do
+    expect(Doc.from_xml('<doc flag="1"/>').element_order).to be_frozen
+  end
+
+  it "does not manufacture typed instances from nothing" do
+    stub_const("PhantomType", Class.new(Lutaml::Model::Type::String) do
+      # Value#initialize casts what it is given, so a cast that
+      # constructs has to bypass it (see phantom_value_spec's Eager).
+      def initialize(value) # rubocop:disable Lint/MissingSuper
+        @value = value
+      end
+
+      def self.cast(value, _options = {})
+        return value if value.is_a?(PhantomType)
+
+        new("phantom(#{value.inspect})")
+      end
+    end)
+    stub_const("PhantomDoc", Class.new(Lutaml::Model::Serializable) do
+      attribute :phantom, PhantomType
+      xml do
+        element "k"
+        map_attribute "p", to: :phantom
+      end
+    end)
+
+    expect(PhantomDoc.from_xml("<k/>").phantom).to be_nil
+  end
+end

data/spec/lutaml/model/parsed_model_mutation_spec.rb

@@ -294,12 +294,18 @@ RSpec.describe "parsed model mutation" do
     end
   end
 
-  # Defect 3: element_order was frozen on parsed models.
+  # element_order on a parsed model: the parsed order array is frozen
+  # (the 0.8.33 contract consumers build thaw-on-demand helpers on,
+  # lutaml-model#795). Mutation goes through reassignment — the
+  # accessor is a public writer.
   describe "element_order on a parsed model" do
-    it "is mutable" do
+    it "is reassignable" do
       model = ParsedModelMutationSpec::Mixed.from_xml('<p><a v="1"/></p>')
 
-      expect { model.element_order << "x" }.not_to raise_error
+      expect(model.element_order).to be_frozen
+      expect do
+        model.element_order = model.element_order.dup << "x"
+      end.not_to raise_error
     end
   end
 
@@ -467,7 +473,7 @@ RSpec.describe "parsed model mutation" do
     it "serializes without raising when element_order holds an Integer" do
       model = ParsedModelMutationSpec::NilColl
         .from_xml("<s><lead>L</lead><item>a</item></s>")
-      model.element_order << 42
+      model.element_order = model.element_order.dup << 42
 
       expect { model.to_xml }.not_to raise_error
     end
@@ -475,7 +481,7 @@ RSpec.describe "parsed model mutation" do
     it "still reconciles the well-formed entries around a foreign one" do
       model = ParsedModelMutationSpec::NilColl
         .from_xml("<s><lead>L</lead><item>a</item></s>")
-      model.element_order.insert(1, 42)
+      model.element_order = model.element_order.dup.insert(1, 42)
       model.items << "b"
 
       xml = model.to_xml

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.35
+  version: 0.8.36
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-17 00:00:00.000000000 Z
+date: 2026-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1685,6 +1685,7 @@ files:
 - spec/lutaml/key_value/transformation/rule_compiler_spec.rb
 - spec/lutaml/key_value/transformation/value_serializer_spec.rb
 - spec/lutaml/key_value/transformation_spec.rb
+- spec/lutaml/model/absent_value_contracts_spec.rb
 - spec/lutaml/model/attribute_apply_value_map_spec.rb
 - spec/lutaml/model/attribute_collection_spec.rb
 - spec/lutaml/model/attribute_default_cache_spec.rb