lutaml-model 0.8.102 → 0.8.103

data/lib/lutaml/xml/leptris/plan_hydrator.rb

@@ -16,13 +16,18 @@ module Lutaml
       # echo neither — leptris-ruby#220).
       module PlanHydrator
         class << self
-          # plan: the compiler's entry for model_class
+          # plan: the compiled plan entry for model_class
           # value: the walk root PlanValue (element)
           # node: the parsed source element (leptris); ordered/mixed
           #   plans rebuild element_order from it and ordered children
           #   hydrate natively against their own nodes
+          # declaration_plan_mode: mirrors from_xml's
+          #   :import_declaration_plan option (:skip records nothing;
+          #   :lazy is honored as :eager — the lazy variant pins the
+          #   raw engine DOM, the retention the eager default exists
+          #   to avoid)
           def call(model_class, plan, value, parent: nil, node: nil,
-                   register: nil)
+                   register: nil, declaration_plan_mode: :eager)
             # The child model's declared lutaml_default_register takes
             # precedence over the ambient register — the same
             # resolve_for_child contract the interpretive path applies.
@@ -32,7 +37,9 @@ module Lutaml
             register = Lutaml::Model::Register.resolve_for_child(
               model_class, register || Lutaml::Model::Config.default_register
             )
-            buckets = node && plan[:needs_nodes] ? element_buckets(node) : nil
+            buckets = if node && plan[:needs_nodes]
+                        element_buckets(node, plan[:contested_names])
+                      end
             attr_kwargs = attributes_kwargs(plan, value, node)
             child_kwargs, children, delegates =
               children_kwargs(model_class, plan, value, buckets, register)
@@ -48,12 +55,31 @@ module Lutaml
                                                register)
             instance.lutaml_parent = parent if parent
             instance.lutaml_root ||= parent&.lutaml_root || parent
+            # Root prefix fidelity (the interpretive transform records
+            # it from the source element): prefixed sources keep their
+            # prefixes through the serialize lane's format
+            # preservation.
+            if parent.nil? && node.respond_to?(:prefix) && node.prefix &&
+                !node.prefix.empty?
+              instance.xml_namespace_prefix = node.prefix
+            end
             # #909: order summaries are per-instance pinned records —
             # read-only consumers skip them via the config.
             if node && plan[:ordered] &&
                 Lutaml::Model::Config.instance.element_order_tracking
               instance.element_order = PlanOrder.build(node)
             end
+            # Root declaration-plan parity (the interpretive
+            # transform's eager mode): consumers and the interpretive
+            # serialize fallback read import_declaration_plan state —
+            # plan-hydrated roots must carry the same in-scope xmlns
+            # declarations or round-trips drop them (#872). The root's
+            # xsi:schemaLocation rides the same state (the
+            # interpretive set_schema_location contract).
+            if parent.nil? && node
+              record_declaration_plan(instance, node, model_class) if declaration_plan_mode != :skip
+              record_schema_location(instance, node)
+            end
             children.each do |child|
               child.lutaml_parent = instance
               child.lutaml_root ||= instance.lutaml_root || instance
@@ -65,6 +91,51 @@ module Lutaml
 
           private
 
+          def record_declaration_plan(instance, node, model_class)
+            ns_data = collect_native_namespaces(node)
+            return if ns_data.empty?
+
+            plan = Lutaml::Xml::DeclarationPlan.from_input_with_locations(
+              ns_data, model_class.mappings_for(:xml)
+            )
+            instance.import_declaration_plan = plan if plan
+          end
+
+          # The interpretive parse stores the root's xsi:schemaLocation
+          # verbatim (set_schema_location); the writer re-emits it.
+          def record_schema_location(instance, node)
+            schema_loc = node.attributes.each_value.find do |a|
+              a.name.to_s.split(":", 2).last == "schemaLocation"
+            end
+            instance.raw_schema_location = schema_loc.value if schema_loc
+          end
+
+          # Same ns_data shape as ModelTransform.collect_element_namespaces,
+          # collected straight off the engine nodes — no wrapper tree.
+          # Iterates children with an inline element filter:
+          # element_children materializes a filtered array per node,
+          # which the niso allocation gate caught at scale.
+          def collect_native_namespaces(element, path = [], result = {})
+            own = element.namespace_definitions
+            unless own.empty?
+              namespaces = {}
+              own.each do |ns|
+                key = ns.prefix || :default
+                namespaces[key] = { uri: ns.href, prefix: ns.prefix,
+                                    format: ns.prefix ? :prefix : :default }
+              end
+              result[path.dup] = namespaces
+            end
+            element.children.each do |child|
+              next unless child.is_a?(::Leptris::XML::Element)
+
+              path.push(child.name)
+              collect_native_namespaces(child, path, result)
+              path.pop
+            end
+            result
+          end
+
           def register
             Lutaml::Model::Config.default_register
           end
@@ -152,8 +223,8 @@ module Lutaml
           # hydration allocated two or three strings per attribute row
           # per instance.
           def plan_attr_rows(plan)
-            plan[:attr_row_names] ||= plan[:attr_rows].map do |rule, attr|
-              [rule, attr, rule.name.to_s]
+            plan[:attr_row_names] ||= plan[:attr_rows].map do |rule, attr, row_name|
+              [rule, attr, row_name || rule.name.to_s]
             end
           end
 
@@ -173,7 +244,9 @@ module Lutaml
             # the block-backed Hash is a fresh object per hydrated row.
             spellings = nil
             row_tags = plan[:row_tags]
-            plan[:rows].each_with_index do |(rule, attr, kind, spelling, delegate), idx|
+            # rubocop:disable Metrics/BlockLength -- one row-kind
+            # dispatch table; splitting it would scatter the contract
+            plan[:rows].each_with_index do |(rule, attr, kind, spelling, delegate, row_type), idx|
               tag = row_tags&.[](idx)
               case kind
               when :scalar
@@ -221,9 +294,11 @@ module Lutaml
                 # node's children. Without one (direct PlanHydrator
                 # use), the subtree fragment-parses interpretively.
                 if buckets
-                  child_type = attr.type(register)
+                  child_type = row_type || attr.type(register)
                   child_plan = PlanCompiler.compile(child_type, register)
-                  items = buckets.fetch(rule.name.to_s, []).map do |n|
+                  selected, = child_bucket(buckets, rule, child_plan,
+                                            contested_name?(plan, rule))
+                  items = (selected || []).map do |n|
                     call(child_type, child_plan,
                          child_plan[:descriptor].walk(n), node: n,
                                                           register: register)
@@ -234,6 +309,26 @@ module Lutaml
                            attr.collection? ? items : items.first)
                   end
                 end
+              when :child_deferred
+                # Uncompilable child (cycles, opted-out shapes): each
+                # source node casts through the attribute — the full
+                # interpretive machinery on the bridged island,
+                # identical semantics to the interpretive path.
+                contested_uri = if plan[:contested_names]&.include?(rule.name.to_s)
+                                  child_type_uri(attr, register)
+                                end
+                elements = deferred_elements(value, rule, buckets,
+                                             contested_uri)
+                next if elements.empty?
+
+                results = elements.map do |element|
+                  attr.cast(element, :xml, register)
+                end
+                unless results.empty?
+                  children.concat(results)
+                  assign(kwargs, delegates, delegate, rule, attr,
+                         attr.collection? ? results : results.first)
+                end
               when :collection_cb
                 values = grouped[rule.name.to_s].to_a.map do |item|
                   item&.string_value
@@ -259,16 +354,30 @@ module Lutaml
                 spellings ||= Hash.new { |h, k| h[k] = [] }
                 spellings[[rule, attr]] << grouped[spelling.to_s].to_a
               when :nested
-                child_type = attr.type(register)
+                child_type = row_type || attr.type(register)
                 child_plan = PlanCompiler.compile(child_type, register)
-                cursor = if child_plan[:needs_nodes] && buckets
-                           buckets.fetch(rule.name.to_s, [])
-                         end
-                items = grouped.fetch(rule.name.to_s, []).each_with_index
-                  .map do |v, i|
-                    call(child_type, child_plan, v,
-                         node: cursor && cursor[i], register: register)
+                selected, = child_bucket(buckets, rule, child_plan,
+                                            contested_name?(plan, rule))
+                if selected && plan[:contested_names]&.include?(rule.name.to_s)
+                  # Contested name: the walk's grouped values cross-echo
+                  # every same-name element into every row — dispatch
+                  # per source node instead (the walk is row-scoped).
+                  items = selected.map do |n|
+                    call(child_type, child_plan,
+                         child_plan[:descriptor].walk(n), node: n,
+                                                          register: register)
                   end
+                else
+                  values = grouped.fetch(rule.name.to_s, [])
+                  cursor = if child_plan[:needs_nodes] && buckets
+                             selected
+                           end
+                  items = values.each_with_index
+                    .map do |v, i|
+                      call(child_type, child_plan, v,
+                           node: cursor && cursor[i], register: register)
+                    end
+                end
                 next if items.empty?
 
                 children.concat(items)
@@ -276,6 +385,7 @@ module Lutaml
                        attr.collection? ? items : items.first)
               end
             end
+            # rubocop:enable Metrics/BlockLength
             unless !spellings || spellings.empty?
               spellings.each do |(rule, attr), groups|
                 # Interpretive order for shared-attribute groups is
@@ -405,11 +515,30 @@ module Lutaml
           # construction only, no parse), falling back to a fragment
           # parse of the captured subtree when no node is available.
           # Both lists are document-ordered for the row's name.
-          def deferred_elements(value, rule, buckets)
-            nodes = buckets && buckets[rule.name.to_s]
-            return nodes.map { |n| bridge_element(n) } if nodes
+          def deferred_elements(value, rule, buckets, contested_uri = nil)
+            return raw_strings(value, rule).map { |raw| fragment_element(raw) } unless buckets
 
-            raw_strings(value, rule).map { |raw| fragment_element(raw) }
+            nodes = buckets[rule.name.to_s]
+            return [] unless nodes
+
+            if contested_uri
+              # Contested name: bind only the (URI, local) matches —
+              # the type's own mapping namespace is the row identity.
+              nodes = buckets[[contested_uri, rule.name.to_s]] || []
+            end
+            nodes.map { |n| bridge_element(n) }
+          end
+
+          def child_type_uri(attr, register)
+            type = attr.type(register)
+            return nil unless type.is_a?(Class) &&
+              type.include?(::Lutaml::Model::Serialize)
+
+            type.mappings_for(:xml, register)&.namespace_uri
+          end
+
+          def contested_name?(plan, rule)
+            plan[:contested_names]&.include?(rule.name.to_s) || false
           end
 
           def bridge_element(node)
@@ -499,7 +628,7 @@ module Lutaml
             # Frozen with the plan: recomputing the tally per hydration
             # showed in the #876-era profile as Enumerable#find/tally churn.
             plan[:sole_claimants] ||= plan[:attr_rows]
-              .map { |rule, _attr| rule.name.to_s }.tally
+              .map { |rule, _attr, row_name| row_name || rule.name.to_s }.tally
               .select { |_n, c| c == 1 }.keys
           end
 
@@ -544,15 +673,48 @@ module Lutaml
           # ordered-child hydration. Only built when the plan's subtree
           # needs source nodes; namespace-qualified models never get
           # here (the compiler keeps them interpretive).
-          def element_buckets(node)
+          # Contested names need (URI, local) node buckets; every other
+          # plan hydrates from the name view alone — the qualified keys
+          # are one array + hash write per child and measured as an
+          # allocation regression on element-heavy corpora (niso gate).
+          def element_buckets(node, contested_names = nil) 
             buckets = {}
+            qualified = contested_names && !contested_names.empty?
             node.children.each do |child|
               next unless child.is_a?(::Leptris::XML::Element)
 
-              (buckets[child.name] ||= []) << child
+              name = child.name
+              (buckets[name] ||= []) << child
+              if qualified
+                uri = child.namespace&.href
+                (buckets[[uri, name]] ||= []) << child if uri
+              end
             end
             buckets
           end
+
+          # (URI, local) child identity — the interpretive matcher's
+          # typed-element dispatch: same-name rows in different
+          # namespaces bind by the child type's exact URI (w14:docId vs
+          # w15:docId under one model). Only CONTESTED names dispatch
+          # exactly — a uniquely-named row binds the whole name bucket
+          # leniently (any qualification), and the uri-keyed view is
+          # built only for plans that carry contested names. Returns
+          # [selected, all] where all is the name bucket (aligned with
+          # the walk's grouped values for position filtering).
+          def child_bucket(buckets, rule, child_plan, contested)
+            name = rule.name.to_s
+            all = buckets ? buckets[name] : nil
+            return [all, all] unless buckets && all && contested
+
+            tree_ns = child_plan[:tree][:ns]
+            exact_uri = tree_ns.is_a?(Hash) ? tree_ns[:exact] : tree_ns
+            if exact_uri
+              qualified = buckets[[exact_uri, name]]
+              return [qualified || [], all]
+            end
+            [all, all]
+          end
         end
       end
     end