lutaml-model 0.8.85 → 0.8.86

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fcfb57e6eb2cff5a7cd47dbe44e7e2baceb10ea5e8f8c22c13fa712d5c8a1fb
-  data.tar.gz: 35c30ed77dfee8d8a06a7a9f8f32f94178c3f092f54d949f831f6a29842d6b27
+  metadata.gz: 91e44ff1cc09c4f38dfe2a18d6d7bad7b70a7828ed6c590c5d808848c0c520eb
+  data.tar.gz: 679150748631c4dbb8063ca6d832028f41c47d9df33561f7f2833535acddb4b1
 SHA512:
-  metadata.gz: 45bf3b55c3d356307035278d46709818fdd8ba4a1520741a58117f7419263b3c438f57097a8e736f1a87dac765bc6523e12479dd54b408aee44a23577f9d3726
-  data.tar.gz: 0c6a92ec24a172e016ee0484a2579efed9c3f0c5c653e85ad2509ae441bb71fcffd6c68c4f72d17a250f4587e21af6072116783cf8229cb997692c48cdcc3d1d
+  metadata.gz: b5c248fcd779fdfa8652d69e8036c38c83b92068f764c56a505154efddee3270bee5cf3dc3cc9ca8f4ef3d056d37bba76cdb45f2e90b698e78478d3368a4d35b
+  data.tar.gz: d696297bd441cb8a1bc9b7b7adf18fa258e8708034e293c181178d91f58b19ad3ccab5e61689af91913b9318ab2120ded1973616e28d79fa741702e709ba2e07

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.85"
+    VERSION = "0.8.86"
   end
 end

data/lib/lutaml/xml/mapping.rb

@@ -59,6 +59,7 @@ module Lutaml
 
         @elements = {}
         @attributes = {}
+        @any_element_rule = nil
         @element_sequence = []
         @content_mapping = nil
         @raw_mapping = nil
@@ -504,6 +505,26 @@ module Lutaml
       # @return [String, nil] the type name
       alias xsd_type type_name
 
+      # Catch-all element mapping: every child element with no
+      # explicit rule routes to one collection attribute. For
+      # parse-side consumption of dynamic vocabularies (semantic__
+      # trees); element_order preserves the original tag names.
+      # Serialization of a catch-all attribute emits the attribute's
+      # declared element name (not per-item originals).
+      def map_any_element(to:, render_nil: false, render_default: false)
+        validate!(nil, to, {}, render_nil, false, type: TYPES[:element])
+        @any_element_rule = MappingRule.new(
+          nil,
+          to: to,
+          render_nil: render_nil,
+          render_default: render_default,
+        )
+        @element_rules_index = nil if instance_variable_defined?(:@element_rules_index)
+        @any_element_rule
+      end
+
+      attr_reader :any_element_rule
+
       def map_instances(to:, polymorphic: {})
         map_element(to, to: to, polymorphic: polymorphic)
       end
@@ -1342,9 +1363,9 @@ module Lutaml
         elsif ["text", "#cdata-section"].include?(name.to_s) && type == "Text"
           content_mapping
         else
-          candidates = mappings.select do |rule|
-            rule.name == name.to_s || rule.name == name.to_sym
-          end
+          candidates = element_rules_index[name.to_s]
+          return @any_element_rule if candidates.nil? && @any_element_rule
+          return nil if candidates.nil?
           return candidates.first if namespace_uri.nil? || candidates.one?
 
           candidates.find do |r|
@@ -1353,6 +1374,29 @@ module Lutaml
         end
       end
 
+      # O(1) name -> rules lookup. Parsing consults this once per
+      # child element; the linear scan over every rule made large
+      # documents quadratic (155s on a 7MB vocabulary tree). Keyed on
+      # the stable source hashes (@elements/@attributes mutate only at
+      # DSL time), never on the per-call mappings array.
+      def element_rules_index
+        cache_key = [@elements.object_id, @attributes.object_id]
+        cached = (@element_rules_index ||= {})
+        idx = cached[cache_key]
+        return idx if idx
+
+        idx = {}
+        ([content_mapping, raw_mapping].compact + @elements.values +
+          @attributes.values).flatten.each do |rule|
+          next if rule.is_a?(::Hash)
+
+          (idx[rule.name.to_s] ||= []) << rule
+        end
+        cached[cache_key] = idx
+        idx
+      end
+      private :element_rules_index
+
       def find_by_to(to)
         mappings.detect { |rule| rule.to.to_s == to.to_s }
       end

data/lib/lutaml/xml/model_transform.rb

@@ -263,6 +263,9 @@ module Lutaml
         # Performance: Resolve xml_mapping once — used for both rules and metadata
         xml_mapping = mappings_for(:xml, effective_register)
         mappings = options[:mappings] || xml_mapping.mappings(effective_register)
+        # Catch-all rule (map_any_element): iterated like any other,
+        # claiming every child no explicit rule matches.
+        mappings += [xml_mapping.any_element_rule].compact if options[:mappings].nil?
         default_namespace = options[:default_namespace]
         ordered_option = options[:ordered]
         mixed_content_option = options[:mixed_content]
@@ -361,7 +364,25 @@ module Lutaml
               options
             end
 
-          value = if rule.raw_mapping?
+          value = if !rule.attribute? && rule.name.nil? &&
+              xml_mapping.any_element_rule.equal?(rule)
+                    # map_any_element: every child element no explicit
+                    # element rule claims, in document order. A name-less
+                    # MappingRule is otherwise indistinguishable from a
+                    # content rule (the dispatch consumed it as doc.text);
+                    # name-derived lookup also cannot express this — it
+                    # re-finds by name, losing order and double-picking.
+                    # The pass walks the document children once; the
+                    # normalize/cast pipeline below handles the rest.
+                    claimed = Set.new(
+                      xml_mapping.mappings(effective_register)
+                        .select { |r| !r.attribute? && r.name }
+                        .flat_map { |r| [r.name.to_s] },
+                    )
+                    doc.element_children.reject do |child|
+                      claimed.include?(child.unprefixed_name)
+                    end
+                  elsif rule.raw_mapping?
                     scoped_raw_inner_xml(doc, xml_mapping)
                   elsif rule.content_mapping?
                     rule.cdata ? doc.cdata : doc.text
@@ -369,6 +390,8 @@ module Lutaml
                       group.size > 1 && attr&.collection?
                     # First rule of a #765 group: match every spelling of
                     # the group so the children merge in document order.
+                    raise "GROUPED-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     if child_names_set &&
                         group.drop(1).none? do |s|
                           child_matches_rule?(s, child_names_set,
@@ -385,9 +408,11 @@ module Lutaml
                       value_for_rule(session, rule, new_opts, attr,
                                      extra_names)
                     end
-                  elsif child_names_set && !rule.attribute? &&
+                  elsif child_names_set && !rule.attribute? && rule.name &&
                       !child_matches_rule?(rule, child_names_set,
                                            default_namespace)
+                    raise "FASTSKIP-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     # Pre-match: no child element matches this rule.
                     # Skip expensive value_for_rule, handle defaults inline.
                     # NOTE: do not "read the instance" here (to_value_for) —
@@ -400,6 +425,8 @@ module Lutaml
                       ::Lutaml::Model::UninitializedClass.instance
                     end
                   else
+                    raise "ELSE-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     # Performance: Pass cached attr to avoid recomputing attribute_for_rule
                     val = value_for_rule(session, rule, new_opts, attr)
 

data/lib/lutaml/xml/parse_session.rb

@@ -24,6 +24,10 @@ module Lutaml
         @instance_is_serialize ||= instance.is_a?(::Lutaml::Model::Serialize)
       end
 
+      def mapping
+        @mapping ||= instance.class.mappings_for(:xml, register)
+      end
+
       # (element, rule name) -> resolved attribute name / matched
       # attribute VALUE for the lenient lookup paths. Both are pure
       # functions of the element and the name; ISO-13849-shaped

data/spec/lutaml/model/any_element_mapping_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+class AnyElementNode < Lutaml::Model::Serializable
+  attribute :id, :string
+  attribute :children, "AnyElementNode", collection: true
+
+  xml do
+    element "root"
+    map_element "id", to: :id
+    map_any_element to: :children
+  end
+end
+
+RSpec.describe AnyElementNode do
+  it "routes unmapped child elements to the catch-all collection" do
+    doc = described_class.from_xml(<<~XML)
+      <root>
+        <id>r-1</id>
+        <semantic__p>hello</semantic__p>
+        <semantic__title>Nested</semantic__title>
+        <semantic__p><semantic__em>deep</semantic__em></semantic__p>
+      </root>
+    XML
+
+    expect(doc.id).to eq("r-1")
+    expect(doc.children.size).to eq(3)
+  end
+
+  it "keeps explicit rules ahead of the catch-all" do
+    doc = described_class.from_xml("<root><id>x</id></root>")
+    expect(doc.id).to eq("x")
+    expect(doc.children).to be_empty
+  end
+
+  it "nests catch-all children recursively" do
+    doc = described_class.from_xml("<root><semantic__p><semantic__em>deep</semantic__em></semantic__p></root>")
+    expect(doc.children.first.children.size).to eq(1)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.85
+  version: 0.8.86
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1697,6 +1697,7 @@ files:
 - spec/lutaml/key_value/when_attribute_spec.rb
 - spec/lutaml/model/absent_value_contracts_spec.rb
 - spec/lutaml/model/adapter_resolver_configured_spec.rb
+- spec/lutaml/model/any_element_mapping_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