lutaml-model 0.8.18 → 0.8.22

data/lib/lutaml/xml/model_transform.rb

@@ -86,8 +86,8 @@ module Lutaml
           end
         end
         root_and_parent_assignment(instance, options)
-        apply_xml_mapping(data, instance, options, child_register,
-                          instance_is_serialize)
+        apply_xml_mapping(ParseSession.new(data, instance, options,
+                                           child_register))
       end
 
       # Build a DeclarationPlan from the parsed element tree's namespace declarations.
@@ -206,17 +206,12 @@ module Lutaml
 
       private
 
-      def apply_xml_mapping(doc, instance, options = {},
-effective_register = nil, instance_is_serialize = nil)
-        # Use threaded flag from data_to_model if provided, otherwise compute
-        instance_is_serialize = instance.is_a?(::Lutaml::Model::Serialize) if instance_is_serialize.nil?
-
-        # Use threaded register from data_to_model if provided, otherwise derive
-        effective_register ||= if instance_is_serialize && instance.lutaml_register
-                                 instance.lutaml_register
-                               else
-                                 lutaml_register
-                               end
+      def apply_xml_mapping(session)
+        doc = session.doc
+        instance = session.instance
+        options = session.options
+        effective_register = session.register
+        instance_is_serialize = session.instance_is_serialize
 
         # Performance: Resolve xml_mapping once — used for both rules and metadata
         xml_mapping = mappings_for(:xml, effective_register)
@@ -303,8 +298,7 @@ effective_register = nil, instance_is_serialize = nil)
                     end
                   else
                     # Performance: Pass cached attr to avoid recomputing attribute_for_rule
-                    val = value_for_rule(doc, rule, new_opts, instance, attr,
-                                         effective_register, instance_is_serialize)
+                    val = value_for_rule(session, rule, new_opts, attr)
 
                     if (val.nil? || ::Lutaml::Model::Utils.uninitialized?(val)) &&
                         (instance.using_default?(rule_to) || rule.render_default)
@@ -437,13 +431,20 @@ _effective_register)
         # - URI format: "http://.../namespace:attr" or "urn:...:attr"
         # - Simple prefix format: "my-ns:attr" (namespace URI is a simple string, not a URI)
         # - Unprefixed: "attr" (no namespace)
-        # Performance: Use map instead of filter_map — converted || rn is always truthy
-        attribute_names = rule_names.map do |rn|
+        # Performance: most rules carry a single name — skip the map and
+        # its result array entirely on that path.
+        if rule_names.size == 1
+          rn = rule_names[0]
           converted = convert_rule_name_to_attribute_name(doc, rn)
-          converted || rn
-        end
+          value = doc.root.find_attribute_value(converted || rn)
+        else
+          attribute_names = rule_names.map do |rn|
+            converted = convert_rule_name_to_attribute_name(doc, rn)
+            converted || rn
+          end
 
-        value = doc.root.find_attribute_value(attribute_names)
+          value = doc.root.find_attribute_value(attribute_names)
+        end
 
         # Fallback: if value is nil, try to match by local name only.
         # This handles the case where the namespace prefix is not declared in the document
@@ -468,25 +469,36 @@ _effective_register)
       def convert_rule_name_to_attribute_name(doc, rule_name)
         return nil unless rule_name.include?(":")
 
-        # Split on last colon to get namespace/localname
-        # This correctly handles URIs with colons (http://... or urn:...)
-        last_colon_index = rule_name.rindex(":")
-        namespace_part = rule_name[0...last_colon_index]
-        local_name = rule_name[(last_colon_index + 1)..]
-
-        # Determine if namespace_part is a URI format or a simple prefix
-        # URI formats: contains "://" (http/https) or starts with "urn:"
-        is_uri_format = namespace_part.include?("://") || namespace_part.start_with?("urn:")
+        # URI-vs-prefix detection works on the whole rule name: the
+        # namespace part is a prefix of rule_name, so "://" anywhere in
+        # the name means a URI-form namespace, and a "urn:" namespace
+        # makes the whole name start with "urn:". Slicing the parts out
+        # first would allocate two strings per call on this hot path.
+        is_uri_format = rule_name.include?("://") || rule_name.start_with?("urn:")
 
+        last_colon_index = rule_name.rindex(":")
         if is_uri_format
-          # URI format: look up attribute by namespace URI and local name
-          doc.root.attributes.values.find do |attr|
-            attr.namespace == namespace_part && attr.unprefixed_name == local_name
+          # URI format: find the attribute whose resolved namespace and
+          # local name spell the rule name. Comparison is by namespace
+          # prefix + local suffix so prefixed attributes (whose
+          # namespaced_name is "prefix:local", never "uri:local") still
+          # match, and unprefixed_name is not called per attribute
+          # (it splits prefixed names and allocates).
+          local_name = rule_name[(last_colon_index + 1)..]
+          doc.root.attributes.each_value.find do |attr|
+            ns = attr.namespace
+            next false if ns.nil? || ns.length > last_colon_index
+            next false unless rule_name.start_with?(ns) && rule_name[ns.length] == ":"
+
+            attr.unprefixed_name == local_name
           end&.name
         else
           # Simple prefix format: look up the actual prefix from document's namespace declarations
           # The namespace_part is the namespace URI declared in the document (e.g., "my-ns").
           # Find the corresponding prefix (e.g., "my") and build "my:val".
+          namespace_part = rule_name[0...last_colon_index]
+          local_name = rule_name[(last_colon_index + 1)..]
+
           ns_data = doc.root.namespaces.values.find do |nd|
             nd.uri == namespace_part
           end
@@ -507,31 +519,43 @@ _effective_register)
 
           last_colon_index = rn.rindex(":")
           local_name = rn[(last_colon_index + 1)..]
+          rule_uri = rn[0...last_colon_index]
+
+          matched_attr = doc.root.attributes.each_value.find do |attr|
+            # Local-name fallback serves two lenient cases only:
+            # - an attribute with an undeclared prefix (raw name keeps the
+            #   colon, namespace unresolvable), the historical purpose;
+            # - an attribute whose resolved namespace IS one of the rule's
+            #   namespace URIs (prefix rebinding, lutaml-model#744).
+            # Everything else — including a definitively namespace-less
+            # attribute and an attribute from a foreign namespace — must
+            # not satisfy the fallback, or a plain rule steals a
+            # namespaced sibling attribute (lutaml-model#758). An
+            # XmlAttribute with a resolved namespace has namespaced_name
+            # "URI:local", so this comparison is allocation-free.
+            if attr.namespace.nil?
+              next false if attr.namespace_prefix.nil? &&
+                !attr.name.include?(":")
 
-          matched_attr = doc.root.attributes.values.find do |attr|
-            # Match by the attribute's namespaced_name, unprefixed_name, or by extracting
-            # local name from the attribute's key (handles unresolved prefixes).
-            attr.namespaced_name == local_name ||
               attr.unprefixed_name == local_name ||
-              (attr.namespace.nil? && ((colon = attr.name.rindex(":")) ? attr.name[(colon + 1)..] : attr.name) == local_name)
+                ((colon = attr.name.rindex(":")) ? attr.name[(colon + 1)..] : attr.name) == local_name
+            else
+              # Prefixed attributes carry namespaced_name "prefix:local",
+              # which a URI-form rule name can never equal — match by the
+              # attribute's resolved namespace instead.
+              attr.namespace == rule_uri && attr.unprefixed_name == local_name
+            end
           end
           return matched_attr&.value if matched_attr
         end
         nil
       end
 
-      def value_for_rule(doc, rule, options, instance, cached_attr = nil,
-                         effective_register = nil,
-                         instance_is_serialize = nil)
-        # Use threaded flag from apply_xml_mapping if provided, otherwise compute
-        instance_is_serialize = instance.is_a?(::Lutaml::Model::Serialize) if instance_is_serialize.nil?
-
-        # Use threaded register from apply_xml_mapping if provided, otherwise derive
-        effective_register ||= if instance_is_serialize && instance.lutaml_register
-                                 instance.lutaml_register
-                               else
-                                 lutaml_register
-                               end
+      def value_for_rule(session, rule, options, cached_attr = nil)
+        doc = session.doc
+        instance = session.instance
+        instance_is_serialize = session.instance_is_serialize
+        effective_register = session.register
 
         # Performance: Use cached attr from caller if available
         attr = cached_attr || attribute_for_rule(rule)
@@ -544,9 +568,14 @@ _effective_register)
         rule_namespace = rule_namespace_set ? rule.namespace : nil
         options[:default_namespace]
 
-        # Enhanced namespace resolution with type support
-        rule_names = resolve_rule_names_with_type(rule, attr, options,
-                                                  effective_register, attr_type)
+        rule_names = if rule.attribute?
+                       resolve_attribute_rule_names(rule, attr, options,
+                                                    effective_register,
+                                                    instance, instance_is_serialize)
+                     else
+                       resolve_rule_names_with_type(rule, attr, options,
+                                                    effective_register, attr_type)
+                     end
 
         return value_for_xml_attribute(doc, rule, rule_names) if rule.attribute?
 
@@ -565,15 +594,25 @@ _effective_register)
                           end
           type_ns_prefix_str = type_ns_class&.prefix_default&.to_s
           type_ns_all_uris = type_ns_class&.all_uris
+          # Adopt the parsed document's namespace (memoized on the session):
+          # when the whole document is out-of-namespace, treat it as an
+          # implicit alias so lenient parsing is lossless (#754).
+          adopted_uri = session.adopted_namespace_uri
+          if adopted_uri && !type_ns_all_uris&.include?(adopted_uri)
+            type_ns_all_uris = (type_ns_all_uris || []) + [adopted_uri]
+          end
         end
 
         # Pre-compute model's namespace class for simple-type alias matching
-        # (Third branch in select loop — was calling instance.class.mappings_for(:xml) per child)
+        # (Third branch in select loop — memoized on the session)
         model_ns_class = if instance_is_serialize &&
             !rule_namespace_set && !attr_type_is_serializable
-                           instance.class.mappings_for(:xml)&.namespace_class
+                           session.xml_mapping&.namespace_class
                          end
-        model_ns_all_uris = model_ns_class&.all_uris
+        # Includes the adopted document namespace (#754): a prefixed child
+        # in the document's (foreign) namespace must still bind by local
+        # name, or its content is silently dropped.
+        model_ns_all_uris = model_ns_class ? session.model_namespace_uris : nil
 
         # Performance: Use cached element children from XmlElement
         # This avoids O(children * rules) scans by pre-filtering once per element
@@ -879,6 +918,44 @@ effective_register = lutaml_register)
         end
       end
 
+      # Match names for an attribute rule, mirroring how serialization
+      # qualifies the same attribute (MappingRule#attribute_match_names):
+      # a rule serialized with a prefix matches only attributes in its
+      # namespace; a rule serialized unprefixed matches only namespace-less
+      # attributes.
+      def resolve_attribute_rule_names(rule, attr, options, effective_register,
+                                       instance, instance_is_serialize)
+        return rule.namespaced_names(options[:default_namespace]) if attr.nil? ||
+          rule.multiple_mappings?
+
+        if instance_is_serialize
+          parent_ns_class, form_default = parent_attribute_context(instance)
+        else
+          parent_ns_class = nil
+          form_default = :unqualified
+        end
+        rule.attribute_match_names(attr, effective_register, parent_ns_class,
+                                   form_default,
+                                   options[:default_namespace])
+      end
+
+      # [namespace_class, attribute_form_default] for the instance's model,
+      # keyed on the model class. Attribute rules of one element share the
+      # model, so a 1-entry cache avoids a mappings_for lookup per rule.
+      def parent_attribute_context(instance)
+        klass = instance.class
+        if @parent_ns_klass == klass && @parent_ns_value
+          return @parent_ns_value
+        end
+
+        ns_class = klass.mappings_for(:xml)&.namespace_class
+        value = [ns_class,
+                 ns_class&.attribute_form_default || :unqualified]
+        @parent_ns_klass = klass
+        @parent_ns_value = value
+        value
+      end
+
       # Resolve rule names with type namespace support
       #
       # @param rule [MappingRule] the mapping rule

data/lib/lutaml/xml/namespace_collector.rb

@@ -37,18 +37,18 @@ module Lutaml
       # @param mapping [Xml::Mapping] the XML mapping for this element
       # @param options [Hash] additional options including mapper_class for recursive calls
       # @return [NamespaceNeeds] namespace needs structure
-      def collect(element, mapping, visited: nil, **)
+      def collect(element, mapping, visited: nil, **options)
         # If this is a top-level call (no visited yet), ensure cleanup
         if visited.nil?
           Thread.current[:namespace_collector_call_stack] = []
           begin
-            collect_internal(element, mapping, visited: nil, **)
+            collect_internal(element, mapping, visited: nil, **options)
           ensure
             Thread.current[:namespace_collector_call_stack] = nil
           end
         else
           # Nested call - don't clean up yet
-          collect_internal(element, mapping, visited: visited, **)
+          collect_internal(element, mapping, visited: visited, **options)
         end
       end
 

data/lib/lutaml/xml/parse_session.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    # Per-parse context threaded through ModelTransform's mapping passes.
+    #
+    # Bundles everything one data_to_model call needs — the parsed doc, the
+    # instance under construction, the effective register, and the flags
+    # derived from them — so apply_xml_mapping and value_for_rule take one
+    # object instead of a growing positional parameter list. Memoizes the
+    # per-parse lookups (mapping, namespace class, adopted document
+    # namespace) that every rule would otherwise recompute.
+    class ParseSession
+      attr_reader :doc, :instance, :options, :register
+
+      def initialize(doc, instance, options, register)
+        @doc = doc
+        @instance = instance
+        @options = options
+        @register = register
+      end
+
+      def instance_is_serialize
+        @instance_is_serialize ||= instance.is_a?(::Lutaml::Model::Serialize)
+      end
+
+      def model_class
+        @model_class ||= instance.class
+      end
+
+      def xml_mapping
+        @xml_mapping ||= model_class.mappings_for(:xml, register)
+      end
+
+      # The document's own namespace when it differs from the model's
+      # bound namespace (lenient, out-of-namespace documents). Adopted as
+      # an implicit alias for element matching (lutaml-model#754).
+      def adopted_namespace_uri
+        @adopted_namespace_uri ||=
+          instance_is_serialize ? instance.original_namespace_uri : nil
+      end
+
+      # Namespace URIs accepted for children of this model: the model's
+      # namespace URIs plus the adopted document namespace when present.
+      def model_namespace_uris
+        @model_namespace_uris ||=
+          begin
+            ns_class = instance_is_serialize ? xml_mapping&.namespace_class : nil
+            uris = ns_class&.all_uris
+            adopted = adopted_namespace_uri
+            if ns_class && adopted && !uris&.include?(adopted)
+              uris = (uris || []) + [adopted]
+            end
+            uris
+          end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/parsed_namespace_set.rb

@@ -135,8 +135,8 @@ module Lutaml
 
       # @yield [declaration] Yields each unique declaration
       # @return [self]
-      def each(&)
-        @by_prefix.values.flatten.uniq.each(&)
+      def each(&block)
+        @by_prefix.values.flatten.uniq.each(&block)
         self
       end
 

data/lib/lutaml/xml/schema/builder.rb

@@ -20,7 +20,7 @@ module Lutaml
         # Supported schema builders (separate from XML parsing adapters)
         SUPPORTED_BUILDERS = %i[nokogiri oga].freeze
 
-        def initialize(adapter_type: nil, options: {}, &)
+        def initialize(adapter_type: nil, options: {}, &block)
           # Use specified adapter, or configured XML adapter, or default to Nokogiri
           requested_adapter = adapter_type || Lutaml::Model::Config.xml_adapter_type || :nokogiri
 
@@ -32,7 +32,7 @@ module Lutaml
                             :nokogiri
                           end
           @options = options
-          @builder = create_builder(&)
+          @builder = create_builder(&block)
         end
 
         # Generate the XSD schema XML string
@@ -45,12 +45,12 @@ module Lutaml
 
         private
 
-        def create_builder(&)
+        def create_builder(&block)
           case @adapter_type
           when :nokogiri
-            Nokogiri.new(@options, &)
+            Nokogiri.new(@options, &block)
           when :oga
-            Oga.new(@options, &)
+            Oga.new(@options, &block)
           end
         end
       end

data/lib/lutaml/xml/schema/xsd/schema_location_mapping.rb

@@ -28,7 +28,7 @@ module Lutaml
           # @param to [String] The target path
           # @param pattern [Boolean, nil] Explicit pattern flag (optional)
           def initialize(attributes = nil, from: nil, to: nil, pattern: nil,
-      **)
+      **options)
             # Handle hash argument from Lutaml::Model deserialization
             if attributes.is_a?(Hash)
               from = attributes[:from] || attributes["from"]
@@ -45,7 +45,7 @@ module Lutaml
             # Use explicit pattern flag if provided, otherwise use detected value
             final_pattern = pattern.nil? ? detected_pattern : pattern
 
-            super(from: from_str, to: to, pattern: final_pattern, **)
+            super(from: from_str, to: to, pattern: final_pattern, **options)
           end
 
           # Convert hash-based mapping to SchemaLocationMapping instance

data/lib/lutaml/xml/schema/xsd.rb

@@ -141,9 +141,7 @@ module Lutaml
           # Trigger autoloads for all XSD model classes to ensure they are
           # registered before parsing begins. This is necessary because
           # type resolution during parsing looks up classes in the register.
-          # rubocop:disable Style/RedundantFetchOverride
           XSD_AUTOLOAD_CLASSES.each { |c| const_get(c) unless c == :VERSION }
-          # rubocop:enable Style/RedundantFetchOverride
 
           # Validate XSD schema structure before parsing (unless disabled)
           if validate_schema && !nested_schema

data/lib/lutaml/xml/schema/xsd_schema.rb

@@ -410,7 +410,8 @@ attr_name)
         def self.get_attribute_xsd_type(attr, attr_type, register,
 _mapping_rule = nil)
           if attr.union?
-            raise Lutaml::Model::UnionSchemaUnsupportedError.new(attr.name, "XSD")
+            raise Lutaml::Model::UnionSchemaUnsupportedError.new(attr.name,
+                                                                 "XSD")
           end
 
           # 1. Check for deprecated attribute-level xsd_type override

data/lib/lutaml/xml/serialization/format_conversion.rb

@@ -89,7 +89,7 @@ module Lutaml
         end
 
         # Override choice to set format: :xml so Choice knows which format it belongs to.
-        def choice(min: 1, max: 1, format: :xml, &)
+        def choice(min: 1, max: 1, format: :xml, &block)
           super
         end
 
@@ -101,9 +101,9 @@ module Lutaml
         # @param format [Symbol] The format
         # @param args [Array] Additional arguments (mapping class for XML)
         # @param block [Proc] The DSL block
-        def process_mapping(format, *args, &)
+        def process_mapping(format, *args, &block)
           if format == :xml && args.any? && args.first.is_a?(Class) && args.first < Lutaml::Xml::Mapping
-            process_xml_mapping_class_inheritance(args.first, &)
+            process_xml_mapping_class_inheritance(args.first, &block)
           else
             super
           end

data/lib/lutaml/xml/transformation/element_builder.rb

@@ -143,7 +143,8 @@ parent_element_form_default)
           # Get transformation for the actual class. Unions resolve the member
           # from the value's own class, like polymorphism.
           child_transformation = if union
-                                   value.class.transformation_for(:xml, register)
+                                   value.class.transformation_for(:xml,
+                                                                  register)
                                  elsif is_polymorphic || is_polymorphic_subtype
                                    actual_class.transformation_for(:xml,
                                                                    register)

data/lib/lutaml/xml/transformation/ordered_applier.rb

@@ -297,7 +297,16 @@ _options)
           end
         end
 
-        # Apply remaining rules (attributes and content/raw)
+        # Apply remaining rules (attributes, content/raw, and any element
+        # rules not represented in element_order).
+        #
+        # The element-type skip that used to live here caused silent data
+        # loss whenever an element-typed attribute was missing from
+        # element_order (e.g. when a direct setter forgot to call
+        # track_order). After the builder-side fix all mutation paths
+        # record into element_order, so this branch is a defense-in-depth
+        # safety net: emit any element-typed rule whose value would
+        # otherwise vanish.
         #
         # @param root [XmlElement] Root element
         # @param model_instance [Object] The model instance
@@ -317,21 +326,107 @@ compiled_rules, mapping, processed_text_nodes)
                              compiled_rules
                            end
 
+          emitted_counts = element_order_coverage(model_instance,
+                                                  compiled_rules)
+
           rules_to_apply.each do |rule|
-            next if rule.option(:mapping_type) == :element
+            mapping_type = rule.option(:mapping_type)
 
-            # Skip content rules if we processed text nodes from element_order
-            if %i[content raw].include?(rule.option(:mapping_type)) &&
+            # Skip content/raw if mixed or text nodes were processed
+            if %i[content raw].include?(mapping_type) &&
                 (mapping&.mixed_content? || processed_text_nodes)
               next
             end
 
+            if mapping_type == :element &&
+                element_rule_already_emitted?(rule, model_instance,
+                                              emitted_counts)
+              next
+            end
+
             next unless valid_mapping?(rule, options)
 
             yield(:apply_rule, rule, nil) if block_given?
           end
         end
 
+        # Count, per element-typed rule, how many entries in element_order
+        # already cover it. Returns a Hash keyed by CompiledRule identity.
+        #
+        # @param model_instance [Object] The model instance
+        # @param compiled_rules [Array<CompiledRule>] The compiled rules
+        # @return [Hash<CompiledRule, Integer>] Coverage counts
+        def element_order_coverage(model_instance, compiled_rules)
+          counts = ::Hash.new(0)
+          return counts unless model_instance.respond_to?(:element_order)
+          return counts unless (order = model_instance.element_order)
+
+          element_rules = compiled_rules.select do |r|
+            r.is_a?(::Lutaml::Model::CompiledRule) &&
+              r.option(:mapping_type) == :element
+          end
+
+          order.each do |object|
+            next unless object.type == "Element"
+
+            object_ns_uri = object.namespace_uri
+            matched = element_rules.find do |r|
+              matches_element_rule?(r, object.name, object_ns_uri)
+            end
+            counts[matched] += 1 if matched
+          end
+
+          counts
+        end
+
+        # Whether an element-typed rule has already been fully emitted
+        # via element_order (or should not be emitted at all by the safety
+        # net). Returns true when:
+        # - the model was not constructed via builder block
+        #   (`@__order_tracking__` is nil/false): parsed models trust
+        #   element_order as the complete source of truth, so the safety
+        #   net must not second-guess it by emitting defaults/uninitialized
+        #   values that the standard path would otherwise have skipped.
+        # - the standard skip logic says the value should be skipped
+        #   (handles defaults, render_nil/render_empty, value_map, etc.)
+        # - or the rule was fully covered by element_order entries
+        #
+        # The safety net targets the bug class where a builder-block
+        # construction bypassed element_order tracking (e.g. via a
+        # mutation path that forgot to call record_mutation). After
+        # Option A, all setter/getter paths record into element_order,
+        # so this branch is defense-in-depth rather than the common
+        # path.
+        #
+        # @param rule [CompiledRule] The element rule
+        # @param model_instance [Object] The model instance
+        # @param emitted_counts [Hash<CompiledRule, Integer>] Coverage map
+        # @return [Boolean]
+        def element_rule_already_emitted?(rule, model_instance,
+emitted_counts)
+          return true unless model_order_tracking_enabled?(model_instance)
+
+          value = extract_ordered_rule_value(rule, model_instance)
+          return true if should_skip_value?(value, rule, model_instance)
+
+          emitted = emitted_counts[rule]
+          if rule.collection?
+            value_length = value.respond_to?(:length) ? value.length : 0
+            emitted >= value_length
+          else
+            emitted.positive?
+          end
+        end
+
+        # Whether the model was constructed via a builder block and thus
+        # has order tracking enabled. Only such models are candidates for
+        # the safety net; parsed models trust element_order as-is.
+        def model_order_tracking_enabled?(model_instance)
+          return false unless model_instance.respond_to?(:order_tracking_enabled?)
+
+          model_instance.order_tracking_enabled?
+        end
+
         # Sort compiled rules so attribute rules follow the captured attribute_order.
         # Non-attribute rules (content, raw) maintain their original position.
         #

data/lib/lutaml/xml/xml_element.rb

@@ -360,6 +360,8 @@ module Lutaml
       end
 
       def find_attribute_value(attribute_name)
+        return if attributes.empty?
+
         # Performance: Use hash index for O(1) lookup instead of linear scan
         ensure_attribute_index