lutaml-model 0.8.92 → 0.8.94

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19d1cc9a53554486e1dda21b67751062851d1990b9878aac1dcd6ccd2542d28e
-  data.tar.gz: 459cecd7cbdd127bb65a52cd6058d027e5139f2926e46d408bea5a28b13f2e7f
+  metadata.gz: '082f3275306fcd89a94f69f68b53d38b0c4c644de743dff261b6bc5166b12ec7'
+  data.tar.gz: 968f9d94e179035695be49649bd9c0b0c2e7e83192661ba3f6d95bbd5803a813
 SHA512:
-  metadata.gz: 92637d4ab1efbd63d746983b4e359f2d49c00469e94bb249a050f36f1b80f15b18ae705245fdd8ab563d854e814fea54ce99993f64dbc17beb9c87555f7b3a95
-  data.tar.gz: 54412f06f6f1bed27f74a85495b414cfc6da3274ab03214220c27edd344aff8cd58f70874fa317fb61b9e8523a04725d69152dfde490b3aa61a2d75540a161ed
+  metadata.gz: 4f06573be9b9da0d12a561522a63d2d14b771a3ff7357fdb92c8d06213fa997efe19470f0d6b6ab39d9c672038715cc6efa1d607cb77dce5487e2134b56335a1
+  data.tar.gz: 275f2d2c74931c84024278dbc5bddcfe18cc267990c0516080605ce1fd2170c5513efcdd141ffbb72b9967cb91fd7ed74b338936a0e1a793aeba2411f8405d09

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

@@ -62,6 +62,28 @@ module Lutaml
             #{lines}
             end
           RUBY
+
+          # lutaml-model#922: raw readers for the deserializer's
+          # unmatched-rule handling. A custom writer that assigns a
+          # *different* attribute mid-parse (relaton's ICS Isoics
+          # fallback; any derived-value pattern) is invisible to the
+          # value_set tracker -- public setters don't mark it -- so the
+          # tracked "still default" state lies. The deserializer needs
+          # the raw stored state to know whether an attribute was
+          # writer-populated: an attribute still holding its
+          # initialized marker (sentinel / lazy collection) is unset;
+          # anything else was written since init and must never be
+          # overwritten by an unmatched rule's default assignment.
+          raw_lines = attrs.map do |name, _attr|
+            <<~RUBY
+              def __lutaml_raw_#{name}
+                @#{name}
+              end
+            RUBY
+          end.join
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            #{raw_lines}
+          RUBY
         end
 
         # Historical getter shape for punctuation-named attributes and
@@ -110,6 +132,28 @@ module Lutaml
           name = attr.name
           register_id = extract_register_id(register)
 
+          # lutaml-model#922: raw-state reader for the deserializer's
+          # unmatched-rule handling. A custom writer that assigns a
+          # *different* attribute mid-parse (relaton's ICS Isoics
+          # fallback; any derived-value pattern) is invisible to the
+          # value_set tracker -- public setters don't mark it -- so the
+          # tracked "still default" state lies. The deserializer needs
+          # the raw stored state to know whether an attribute was
+          # writer-populated: still holding the initialized marker
+          # (sentinel / lazy collection) means unset; anything else was
+          # written since init and must never be overwritten by an
+          # unmatched rule's default assignment. Declared here (not in
+          # the state-defaults compilation) so late declarations get it
+          # too -- XMI's extension loader declares attributes after
+          # first parse.
+          if name.to_s.match?(PLAIN_NAME)
+            model.class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+              def __lutaml_raw_#{name}
+                @#{name}
+              end
+            RUBY
+          end
+
           if attr.enum?
             add_enum_methods_to_model(
               model,
@@ -354,6 +398,11 @@ module Lutaml
           attr = Attribute.new(name, type, options)
           @attributes[name] = attr
           @merged_attributes_cache = nil
+          # Attributes can be declared after the model has been
+          # instantiated (forward references, post-hoc declarations);
+          # the interned writer table from the first instantiation must
+          # not outlive the attribute set it was built from.
+          @instantiate_writers = nil
           invalidate_state_defaults!
           define_attribute_methods(attr)
 

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

@@ -392,6 +392,22 @@ module Lutaml
               # set (nil when no default), never left as the
               # uninitialized sentinel — readers and formatters touch
               # absent attributes freely.
+              #
+              # lutaml-model#922: unless a custom writer already
+              # populated it. An earlier kwarg's writer may have
+              # assigned this attribute as a side effect (relaton's ICS
+              # populates <text> from the Isoics dataset inside code=);
+              # the raw state is the truth — still at its initialized
+              # marker (sentinel / lazy collection) means unset, and
+              # only then is the default seeded. The writer's own
+              # value_set_for (inside the compiled writer) already
+              # marked it set, so it renders.
+              raw = instance.public_send(:"__lutaml_raw_#{name}")
+              unset = raw.nil? ||
+                raw.equal?(Lutaml::Model::UninitializedClass.instance) ||
+                raw.equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+              next unless unset
+
               default = attr.default_value(register_id, instance)
               value = if Lutaml::Model::Utils.uninitialized?(default)
                         nil

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.92"
+    VERSION = "0.8.94"
   end
 end

data/lib/lutaml/xml/model_transform.rb

@@ -345,12 +345,11 @@ module Lutaml
         mappings.each do |rule|
           record = records&.[](rule)
 
-          # #903: replay-or-drop unmatched named element rules before
-          # any per-rule machinery (see replay_unmatched_rule).
-          if replay_unmatched_rule(child_names_set, record, rule,
-                                   instance, defaults_used, xml_mapping)
-            next
-          end
+          # #903/#922: replay-or-drop unmatched rules; never clobber
+          # a mid-parse custom-writer assignment.
+          next if replay_unmatched_rule(child_names_set, record, rule,
+                                        instance, defaults_used,
+                                        xml_mapping)
 
           rule_to = rule.to
 
@@ -436,11 +435,19 @@ module Lutaml
                     # NOTE: do not "read the instance" here (to_value_for) —
                     # the compiled getters materialize lazy collections on
                     # first read, which tripled parse allocations when tried.
+                    if writer_populated?(record, instance)
+                      instance.value_set_for(rule_to)
+                      next
+                    end
                     if instance.using_default?(rule_to) || rule.render_default
                       defaults_used << rule_to
                       attr&.default(effective_register) || rule.to_value_for(instance)
                     else
-                      ::Lutaml::Model::UninitializedClass.instance
+                      # The attribute already holds an explicit value --
+                      # assigned by a matched rule or by a custom writer
+                      # mid-parse (lutaml-model#922). An unmatched rule
+                      # must not overwrite it with nil.
+                      next
                     end
                   else
                     raise "ELSE-BODY" if ENV["CATCHDBG"] && rule.name.nil?
@@ -857,7 +864,7 @@ _effective_register)
 
       Record = Struct.new(:attr, :derived, :group_skip, :valid,
                           :unmatched_mode, :replay_writer,
-                          :unmatched_names)
+                          :unmatched_names, :raw_reader)
 
       def compiled_rule_records(model_class, register, grouped_plain_rules)
         return {}.compare_by_identity unless model_class.include?(Lutaml::Model::Serialize)
@@ -946,6 +953,15 @@ _effective_register)
             unmatched_mode,
             replay_writer,
             unmatched_names,
+            # lutaml-model#922: raw-state reader for the attribute,
+            # when the compiled init seeds it (plain names -- the same
+            # set compile_state_defaults! writes). Delegated rules name
+            # an attribute on the delegate object, not on this
+            # instance, so they get no raw reader.
+            if attr && rule.delegate.nil? &&
+                rule.to.to_s.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
+              :"__lutaml_raw_#{rule.to}"
+            end,
           )
         end
         entry = Struct.new(:version, :records).new(version, records)
@@ -1630,6 +1646,24 @@ effective_register = lutaml_register)
       # (the visit ended at the omission gate or was a guarded next)
       # writes nothing; :write_nil replays the nil the default value
       # map produces, plus the flag churn. Returns true when handled.
+      # lutaml-model#922: whether the attribute holds anything other
+      # than its initialized marker (uninitialized sentinel / lazy
+      # collection) — i.e. a custom writer populated it mid-parse.
+      def writer_populated?(record, instance)
+        return false unless record&.raw_reader
+
+        !raw_initialized?(record, instance)
+      end
+
+      # True when the attribute still holds the value the compiled init
+      # seeded (uninitialized sentinel / lazy collection) — i.e. nothing
+      # has written it since.
+      def raw_initialized?(record, instance)
+        raw = instance.public_send(record.raw_reader)
+        raw.equal?(::Lutaml::Model::UninitializedClass.instance) ||
+          raw.equal?(::Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+      end
+
       def replay_unmatched_rule(child_names_set, record, rule, instance,
                                 defaults_used, xml_mapping)
         return false unless child_names_set && record
@@ -1647,9 +1681,30 @@ effective_register = lutaml_register)
 
         return true if mode == :drop
 
-        defaults_used << rule.to
+        # The visited path picks the default branch only while the
+        # attribute still reads as default-valued; once another rule
+        # or a custom writer set it mid-parse, the omission gate ends
+        # the visit with no write. Mirror that: replay writes only
+        # while unset, and drops otherwise (a custom writer may have
+        # populated the attribute — relaton's ICS Isoics-fallback
+        # pattern).
+        rule_to = rule.to
+        unless instance.using_default?(rule_to)
+          return true
+        end
+
+        # lutaml-model#922: a custom writer may have populated the
+        # attribute mid-parse without going through the tracker (the
+        # compiled setters are direct ivar writes), so the tracked
+        # flag above can lie. The raw state is the truth: still at its
+        # initialized marker (sentinel / lazy collection) means unset
+        # -- the visited path wrote the default there; anything else
+        # is a writer assignment this replay must not clobber.
+        return true unless raw_initialized?(record, instance)
+
+        defaults_used << rule_to
         instance.public_send(record.replay_writer, nil)
-        instance.value_set_for(rule.to)
+        instance.value_set_for(rule_to)
         true
       end
 

data/spec/lutaml/model/late_attribute_declaration_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Attributes can be declared after the model has been instantiated
+# (forward references, post-hoc declarations). The interned writer
+# table built during the first instantiation must not outlive the
+# attribute set it was built from.
+RSpec.describe "attributes declared after first instantiation" do
+  it "initializes attributes added after an earlier instantiation" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+    end
+
+    klass.new(name: "first")
+
+    klass.attribute :size, :string
+    instance = klass.new(name: "second", size: "L")
+
+    expect(instance.name).to eq("second")
+    expect(instance.size).to eq("L")
+  end
+
+  it "keeps earlier instances unaffected" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+    end
+
+    first = klass.new(name: "first")
+    klass.attribute :size, :string
+
+    expect(first.name).to eq("first")
+    expect(first.respond_to?(:size)).to be(true)
+  end
+end

data/spec/lutaml/model/writer_assigned_attribute_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module WriterAssigned
+  class Plain < Lutaml::Model::Serializable
+    attribute :code, :string
+    attribute :text, :string
+
+    xml do
+      element "probe"
+      map_element "code", to: :code
+      map_element "text", to: :text
+    end
+
+    def code=(val)
+      super
+      self.text = "derived-#{val}" if val
+    end
+  end
+
+  class Defaulted < Lutaml::Model::Serializable
+    attribute :code, :string
+    attribute :text, :string, default: -> { "" }
+
+    xml do
+      element "probe"
+      map_element "code", to: :code
+      map_element "text", to: :text
+    end
+
+    def code=(val)
+      super
+      self.text = "derived-#{val}" if val
+    end
+  end
+end
+
+# lutaml-model#922: a custom writer that assigns a *different* attribute
+# mid-parse (relaton's Relaton::Bib::ICS populates <text> from the Isoics
+# dataset inside code=) must survive the deserializer's unmatched-rule
+# handling: the default seeding in Initialization#instantiate and the
+# unmatched-rule replay must never overwrite a value a writer assigned.
+RSpec.describe "attributes assigned inside another attribute's writer" do
+  %i[Plain Defaulted].each do |klass_name|
+    klass = WriterAssigned.const_get(klass_name)
+
+    describe "with #{klass_name.to_s.downcase} text attribute" do
+      it "keeps the derived value through from_xml" do
+        instance = klass.from_xml("<probe><code>67.060</code></probe>")
+
+        expect(instance.text).to eq("derived-67.060")
+      end
+
+      it "renders the derived value on to_xml" do
+        instance = klass.from_xml("<probe><code>67.060</code></probe>")
+
+        expect(instance.to_xml).to include("<text>derived-67.060</text>")
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.92
+  version: 0.8.94
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-03 00:00:00.000000000 Z
+date: 2026-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1759,6 +1759,7 @@ files:
 - spec/lutaml/model/jsonl_spec.rb
 - spec/lutaml/model/key_value_data_model/key_value_element_spec.rb
 - spec/lutaml/model/key_value_mapping_spec.rb
+- spec/lutaml/model/late_attribute_declaration_spec.rb
 - spec/lutaml/model/lazy_collection_spec.rb
 - spec/lutaml/model/liquefiable_lazy_spec.rb
 - spec/lutaml/model/liquefiable_spec.rb
@@ -1872,6 +1873,7 @@ files:
 - spec/lutaml/model/value_policy_spec.rb
 - spec/lutaml/model/value_transformation_comprehensive_spec.rb
 - spec/lutaml/model/with_child_mapping_spec.rb
+- spec/lutaml/model/writer_assigned_attribute_spec.rb
 - spec/lutaml/model/xml_decoupling_spec.rb
 - spec/lutaml/model/xsd_form_default_patterns_spec.rb
 - spec/lutaml/model/xsd_patterns_spec.rb