lutaml-model 0.8.39 → 0.8.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15f9489eb4db353b481f160703e848e35b730cef179d32874941fc537ed962d3
-  data.tar.gz: f0067a5ffc4d66c8312d9cc478d9bd7d1771d9b639111c3158956b2d98e4468e
+  metadata.gz: 597b465123fe390703bdb760a4f6e18e4069b55bea8998633e2a4c0c7f5fcb9c
+  data.tar.gz: e848597e1ad2cef05670d8dc8de6f7480bf028fde627021c5a61f554ad99a2f0
 SHA512:
-  metadata.gz: 9f1372cbf492e141015524382a3ac98cdc5f484441d70c593b7ad67b9021bfa959732700679534bb3690f86c064e3a1a82269833c5c73794fe87af24f21d239b
-  data.tar.gz: '048d412becdba7a8a99070740663d0d0a33e88d02018708818ce816d1ba4669a1f26efbf08d0c67390818c5efede0e362ef8f1785536c4233a2fa6dadd07da61'
+  metadata.gz: 231f9601a9ce76ae516a6435b2c7185e15c2cc6680d0aefbad27ef328b25f67f0ed2635be8319eff6c3a64338f3bd2f9855ab1daa51058018345eb77cf3aa0d9
+  data.tar.gz: 88af6f65b2fadf91990f6f6f10a03a799007acda351d87a059f00325c85514291fbaccfd99580dd1daac3090bd61f4aa1ec26efffd058438c7e6abdd9a53cea4

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

@@ -129,6 +129,7 @@ module Lutaml
               end
             end
           elsif attr.unresolved_type == Lutaml::Model::Type::Reference
+            Lutaml::Model::Store.reference_types_in_use!
             define_reference_methods(name, register_id)
           else
             define_regular_attribute_methods(name, attr)

data/lib/lutaml/model/store.rb

@@ -33,11 +33,30 @@ module Lutaml
           @instance ||= new
         end
 
+        # lutaml-model#808: Ruby 3.3's GC has a WeakMap-mark hazard under
+        # heavy insert churn (freed slot dereferenced at wmap mark time).
+        # Registration is only ever consumed by `ref:` resolution — when
+        # no Reference-typed attribute exists anywhere, nothing can
+        # resolve, so registration is skipped entirely and the WeakMap
+        # stays quiet. Set the first time an attribute with a Reference
+        # type is defined.
+        # Not memoized `||=` — the setter flips it to true for the
+        # process lifetime and reads must see that.
+        def reference_types_in_use?
+          @reference_types_in_use ? true : false
+        end
+
+        def reference_types_in_use!
+          @reference_types_in_use = true
+        end
+
         def reset!
           @instance = new
         end
 
         def register(object)
+          return unless reference_types_in_use?
+
           instance.register(object)
         end
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.39"
+    VERSION = "0.8.40"
   end
 end

data/lib/lutaml/xml/adapter/plan_based_builder.rb

@@ -299,13 +299,23 @@ module Lutaml
           # Create element
           xml.create_and_add_element(tag_name, attributes: attributes,
                                                prefix: prefix) do |inner_xml|
-            # Handle raw content (map_all directive)
+            # Handle raw content (map_all directive). lutaml-model#223:
+            # with coexisting mappings the raw remainder is the TAIL —
+            # mapped children render first through the normal paths
+            # below, then the fragment is appended. Standalone map_all
+            # (raw is the whole content) keeps the historical
+            # raw-only rendering by fronting the fragment and skipping
+            # children only when there is nothing mapped.
             has_raw_content = false
             if element.is_a?(Lutaml::Xml::DataModel::XmlElement)
               raw_content = element.raw_content
               if raw_content && !raw_content.to_s.empty?
-                inner_xml.add_xml_fragment(inner_xml, raw_content.to_s)
-                has_raw_content = true
+                if element.children.empty?
+                  inner_xml.add_xml_fragment(inner_xml, raw_content.to_s)
+                  has_raw_content = true
+                else
+                  (tail_raw_fragments ||= []) << raw_content.to_s
+                end
               end
             end
 
@@ -343,6 +353,9 @@ module Lutaml
                 end
               end
             end
+            (tail_raw_fragments || []).each do |fragment|
+              inner_xml.add_xml_fragment(inner_xml, fragment)
+            end
           end
         end
 

data/lib/lutaml/xml/adapter/xml_serializer.rb

@@ -268,11 +268,20 @@ module Lutaml
           attributes["xmlns"] = "" if needs_xmlns_blank
 
           xml.create_and_add_element(qualified_name, attributes: attributes) do
+            tail_raw = nil
             if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
               raw_content = xml_element.raw_content
               if raw_content && !raw_content.to_s.empty?
-                xml.add_xml_fragment(xml, raw_content.to_s)
-                return
+                # lutaml-model#223: with coexisting map_all, the raw
+                # remainder is the tail — mapped children render first.
+                # Standalone map_all (no mapped children) keeps the
+                # historical raw-only rendering.
+                if xml_element.children.empty?
+                  xml.add_xml_fragment(xml, raw_content.to_s)
+                  return
+                end
+
+                tail_raw = raw_content.to_s
               end
             end
 
@@ -306,6 +315,8 @@ module Lutaml
               end
             end
 
+            xml.add_xml_fragment(xml, tail_raw) if tail_raw
+
             if xml_element.text_content
               if xml_element.cdata
                 xml.cdata(xml_element.text_content.to_s)

data/lib/lutaml/xml/adapter_element.rb

@@ -109,6 +109,13 @@ module Lutaml
         children.map(&:to_xml).join
       end
 
+      # The element including its own tags — the building block for
+      # scoped raw capture (#223): an unclaimed child contributes its
+      # whole subtree verbatim.
+      def inner_xml_or_self
+        to_xml
+      end
+
       private
 
       def build_element_xml(builder)

data/lib/lutaml/xml/mapping.rb

@@ -979,9 +979,14 @@ module Lutaml
                                "is allowed with #{TYPES[:all_content]}"
         end
 
-        if !(elements.empty? && content_mapping.nil?) && type == TYPES[:all_content]
-          raise StandardError,
-                "#{TYPES[:all_content]} is not allowed with other mappings"
+        if type == TYPES[:all_content] &&
+            !(elements.empty? && content_mapping.nil?)
+          # lutaml-model#223: map_all may coexist with mapped siblings.
+          # The raw capture receives only the UNCLAIMED content — the
+          # verbatim subtree minus children matched by element rules.
+          # The historical exclusivity raised here; the coexistence
+          # contract is enforced by scoped capture on parse and
+          # remainder-after-mapped emission on serialize.
         end
       end
 

data/lib/lutaml/xml/model_transform.rb

@@ -55,14 +55,17 @@ module Lutaml
           # ISO-13849 profile). Memoize one instance per (element, class)
           # for the whole parse; the memo travels in the propagated
           # deserialization options.
-          memo = options[:__lutaml_child_memo] ||= {}
-          memo_key = [data.object_id, model_class.object_id]
-          if (existing = memo[memo_key])
+          # Nested identity maps keyed on the element object itself —
+          # flat object_id pairs could collide after GC id reuse on
+          # long parses (#808 audit).
+          memo = options[:__lutaml_child_memo] ||= {}.compare_by_identity
+          per_class = (memo[data] ||= {}.compare_by_identity)
+          if (existing = per_class[model_class])
             return existing
           end
 
           instance = model_class.allocate_for_deserialization(child_register)
-          memo[memo_key] = instance
+          per_class[model_class] = instance
         else
           instance = model_class.new
           register_accessor_methods_for(instance, child_register)
@@ -345,7 +348,7 @@ module Lutaml
             end
 
           value = if rule.raw_mapping?
-                    doc.root.inner_xml
+                    scoped_raw_inner_xml(doc, xml_mapping)
                   elsif rule.content_mapping?
                     rule.cdata ? doc.cdata : doc.text
                   elsif (group = grouped_plain_rules[rule_to]) &&
@@ -713,6 +716,23 @@ _effective_register)
       # lutaml-model#154: decode HTML entities for mappings that opted in
       # (`html_entities` in the xml block). Values stay untouched
       # otherwise — XML keeps undefined entities literal by design.
+      # lutaml-model#223: with coexisting map_all, the raw capture is
+      # the verbatim subtree MINUS the children claimed by element
+      # rules (they hydrate their own attributes). Standalone map_all
+      # (no element rules) keeps the full inner_xml.
+      def scoped_raw_inner_xml(doc, xml_mapping)
+        claimed = []
+        xml_mapping&.elements&.each do |element_rule|
+          Array(element_rule.name).each { |n| claimed << n.to_s }
+        end
+        return doc.root.inner_xml if claimed.empty?
+
+        doc.root.element_children.reject do |child|
+          claimed.include?(child.unprefixed_name) ||
+            claimed.include?(child.name)
+        end.map(&:inner_xml_or_self).join
+      end
+
       def decode_html_entities_value(value, enabled)
         return value if value.nil? || !value.is_a?(String)
         return value unless enabled

data/spec/lutaml/model/map_all_spec.rb

@@ -185,28 +185,32 @@ module MapAllSpec
       end
     end
 
-    describe "invalid mapping combinations" do
-      it "raises error when combining map_all with other mappings" do
-        expect do
-          InvalidDocument.json do
+    describe "coexistence with other mappings (#223)" do
+      it "captures only unclaimed content alongside mapped elements" do
+        doc_class = Class.new(Lutaml::Model::Serializable) do
+          attribute :title, :string
+          attribute :rest, :string
+
+          xml do
+            element "eref"
             map_element "title", to: :title
+            map_all to: :rest
           end
-        end.to raise_error(
-          StandardError,
-          "map_all is not allowed with other mappings",
-        )
-      end
+        end
 
-      it "raises error when combining other mappings are used with map_all" do
-        expect do
-          InvalidDocument.yaml do
-            map_element "title", to: :title
-            map_all to: :content
-          end
-        end.to raise_error(
-          StandardError,
-          "map_all is not allowed with other mappings",
-        )
+        source = %(<eref><title>T</title><p>para</p><note>N</note></eref>)
+        parsed = doc_class.from_xml(source)
+        expect(parsed.title).to eq("T")
+        expect(parsed.rest).to eq("<p>para</p><note>N</note>")
+
+        out = doc_class.to_xml(parsed)
+        expect(out).to include("<title>T</title>")
+        expect(out).to include("<p>para</p>")
+        expect(out).to include("<note>N</note>")
+
+        reparsed = doc_class.from_xml(out)
+        expect(reparsed.title).to eq("T")
+        expect(reparsed.rest).to eq("<p>para</p><note>N</note>")
       end
     end
   end

data/spec/lutaml/model/store_spec.rb

@@ -3,6 +3,13 @@
 require "spec_helper"
 
 RSpec.describe Lutaml::Model::Store do
+  before do
+    # Registration only runs when a Reference-typed attribute exists
+    # somewhere (#808); the internal specs opt in explicitly.
+    described_class.reference_types_in_use!
+    described_class.clear 
+  end
+
   let(:model_class) do
     Class.new(Lutaml::Model::Serializable) do
       attribute :id, :string
@@ -10,7 +17,6 @@ RSpec.describe Lutaml::Model::Store do
     end
   end
 
-  before { described_class.clear }
   after { described_class.clear }
 
   describe "#register and #resolve" do

data/spec/lutaml/xml/mapping_spec.rb

@@ -974,7 +974,6 @@ RSpec.describe Lutaml::Xml::Mapping do
       end
 
       context "when mixed content is true and child is content_mapping" do
-        let(:map_all_error) { "map_all is not allowed with other mappings" }
         let(:invalid_element) { "must be defined without namespace" }
         let(:mfenced) do
           <<~XML
@@ -994,7 +993,7 @@ RSpec.describe Lutaml::Xml::Mapping do
           XML
         end
 
-        it "raises error when map_all used in content_mapping without custom methods" do
+        it "allows map_all alongside element mappings (#223)" do
           original_mapping = XmlMappingSpec::MmlMath.mappings[:xml].deep_dup
 
           begin
@@ -1005,7 +1004,7 @@ RSpec.describe Lutaml::Xml::Mapping do
               XmlMappingSpec::MmlMath.xml do
                 map_all to: :all_content
               end
-            end.to raise_error(StandardError, map_all_error)
+            end.not_to raise_error
           ensure
             XmlMappingSpec::MmlMath.instance_variable_set(:@mappings,
                                                           { xml: original_mapping })
@@ -1013,16 +1012,16 @@ RSpec.describe Lutaml::Xml::Mapping do
           end
         end
 
-        it "can be defined after any other mapping" do
+        it "still validates its own arguments when combined (#223)" do
           original_mapping = XmlMappingSpec::MmlMath.mappings[:xml].deep_dup
 
           begin
             expect do
               XmlMappingSpec::MmlMath.xml do
-                map_all to: :all_content
-                namespace XmiNewNamespace
+                map_all to: :all_content, namespace: "http://explicit.ns"
               end
-            end.to raise_error(StandardError, map_all_error)
+            end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError,
+                               /namespace is not allowed/)
           ensure
             XmlMappingSpec::MmlMath.instance_variable_set(:@mappings,
                                                           { xml: original_mapping })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.39
+  version: 0.8.40
 platform: ruby
 authors:
 - Ribose Inc.