lutaml-model 0.8.18 → 0.9.1

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

@@ -108,24 +108,20 @@ module Lutaml
                 current = instance_variable_get(:"@#{name}") || []
                 new_value = current.is_a?(Array) ? current + [value] : value
                 instance_variable_set(:"@#{name}", new_value)
-                # Track order for mixed_content serialization
-                track_order(name, value, nil) if @__order_tracking__
+                record_mutation(name, value)
                 value
               end
             end
           else
             # For non-collection attributes, getter accepts optional argument
-            # for builder-style syntax: g.description(value) sets the value
+            # for builder-style syntax: g.description(value) sets the value.
+            # Tracking happens inside the setter, so no duplicate call here.
             define_method(name) do |*args|
               if args.empty?
                 instance_variable_get(:"@#{name}")
               else
-                # Builder-style: g.description(value) sets the value
-                value = args.first
-                public_send(:"#{name}=", value)
-                # Track order for mixed_content serialization
-                track_order(name, value, nil) if @__order_tracking__
-                value
+                public_send(:"#{name}=", args.first)
+                args.first
               end
             end
           end
@@ -156,12 +152,16 @@ module Lutaml
                 else
                   instance_variable_set(:"@#{name}", value)
                 end
+                # Track one entry per item so element_order reflects the
+                # number of <name> elements that will be emitted.
+                record_mutation_collection(name, value)
               end
             else
               define_method(:"#{name}=") do |value|
                 value_set_for(name)
                 value = attr.cast_value(value, lutaml_register)
                 instance_variable_set(:"@#{name}", value)
+                record_mutation(name, value)
               end
             end
           end
@@ -188,6 +188,7 @@ module Lutaml
 
           attr = Attribute.new(name, type, options)
           @attributes[name] = attr
+          @merged_attributes_cache = nil
           define_attribute_methods(attr)
 
           attr

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

@@ -75,6 +75,61 @@ module Lutaml
           mapping&.ordered? || false
         end
 
+        # Whether this instance was constructed via a builder block and
+        # therefore records mutations into element_order. Parsed models
+        # and instances constructed without a block do not track; their
+        # element_order (if any) comes from the parser and is treated as
+        # the complete source of truth by the serializer.
+        # @return [Boolean]
+        def order_tracking_enabled?
+          @__order_tracking__ ? true : false
+        end
+
+        # Record a singular attribute mutation in element_order.
+        #
+        # No-op unless order tracking is enabled (i.e. the instance was
+        # constructed via a builder block on an ordered/mixed_content
+        # model). This is the single entry point for singular mutations
+        # and is called from generated setters and getter-with-arg paths
+        # so that direct setters (`x.foo = v`) and appender calls
+        # (`x.foo(v)`) behave identically.
+        #
+        # Returns `value` so generated setters preserve Ruby's setter
+        # contract: `obj.foo = v` evaluates to `v`. Callers like
+        # `obj.foo || (obj.foo = [])` depend on this.
+        #
+        # @param attribute_name [Symbol] The attribute being mutated
+        # @param value [Object, nil] The value being set; stored as text
+        #   content for content-mapped attributes, ignored otherwise
+        # @return [Object] the passed value
+        def record_mutation(attribute_name, value = nil)
+          return value unless @__order_tracking__
+
+          track_order(attribute_name, value, nil)
+          value
+        end
+
+        # Record a collection-attribute mutation in element_order.
+        #
+        # Emits one entry per item so that element_order length matches
+        # the number of serialized child elements. No-op when tracking
+        # is disabled, when the value is nil/empty, or when the
+        # collection's frozen sentinel is preserved (no real data).
+        #
+        # Returns `value` so generated setters preserve Ruby's setter
+        # contract (see {record_mutation}).
+        #
+        # @param attribute_name [Symbol] The collection attribute
+        # @param value [Object, nil] The value assigned to the collection
+        # @return [Object] the passed value
+        def record_mutation_collection(attribute_name, value)
+          return value unless @__order_tracking__
+          return value if value.nil? || Lutaml::Model::Utils.uninitialized?(value)
+
+          Array(value).each { |item| track_order(attribute_name, item, nil) }
+          value
+        end
+
         private
 
         # Intercept method calls to track order for mixed_content

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

@@ -115,13 +115,18 @@ module Lutaml
         # Get all attributes for this model
         #
         # Merges class-level attributes with register-specific attributes.
+        # Memoized per register: this is on the per-element deserialization
+        # hot path, and the merged hash is stable until an attribute, import
+        # or register record mutates (those clear @merged_attributes_cache).
         #
         # @param register [Symbol, nil] The register context
         # @return [Hash] The attributes hash
         def attributes(register = nil)
           ensure_imports!(register) if finalized?
           if @register_records&.any?
-            @attributes.merge(@register_records[extract_register_id(register)][:attributes])
+            register_id = extract_register_id(register)
+            (@merged_attributes_cache ||= {})[register_id] ||=
+              @attributes.merge(@register_records[register_id][:attributes])
           else
             @attributes
           end
@@ -183,6 +188,9 @@ module Lutaml
             GlobalContext.resolver.clear_cache(register_id)
           end
 
+          # Clear memoized attribute merge (see .attributes)
+          @merged_attributes_cache = nil
+
           # Clear per-Attribute type caches (stale entries from GC'd TypeContext objects)
           class_attributes.each_value(&:clear_type_cache)
           @register_records&.each_value do |record|
@@ -370,7 +378,6 @@ module Lutaml
               instance_variable_get(:"@#{name}")
             else
               public_send(:"#{name}=", args.first)
-              track_order(name, args.first, nil) if @__order_tracking__
               args.first
             end
           end
@@ -380,6 +387,7 @@ module Lutaml
             reg_attr = resolve_register_attr(name)
             value = reg_attr.cast_value(value, lutaml_register)
             instance_variable_set(:"@#{name}", value)
+            record_mutation(name, value)
           end
         end
 
@@ -395,7 +403,7 @@ module Lutaml
               current = [] if current.equal?(LAZY_EMPTY_COLLECTION)
               new_value = current.is_a?(Array) ? current + [value] : value
               instance_variable_set(:"@#{name}", new_value)
-              track_order(name, value, nil) if @__order_tracking__
+              record_mutation(name, value)
               value
             end
           end
@@ -411,6 +419,7 @@ module Lutaml
             else
               instance_variable_set(:"@#{name}", value)
             end
+            record_mutation_collection(name, value)
           end
         end
 

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

@@ -121,6 +121,7 @@ module Lutaml
           @register_records[register_id][:choice_attributes].concat(
             deep_duplicate_choice_attributes(model, register_id),
           )
+          @merged_attributes_cache = nil
         end
         private :register_only_import_model_attributes
 

data/lib/lutaml/model/serialize.rb

@@ -175,18 +175,19 @@ module Lutaml
         @using_default[attribute_name]
       end
 
-      # rubocop:disable Style/ArgumentsForwarding -- anonymous * requires Ruby 3.2+, but required_ruby_version >= 3.0
-      def method_missing(method_name, *args)
+      def method_missing(method_name, *, &)
         if method_name.to_s.end_with?("=") && attribute_exist?(method_name)
           define_singleton_method(method_name) do |value|
             instance_variable_set(:"@#{method_name.to_s.chomp('=')}", value)
           end
-          send(method_name, *args)
+          send(method_name, *)
+        elsif ::Lutaml::Model::Attribute.default_evaluation? &&
+            self.class.respond_to?(method_name)
+          self.class.public_send(method_name, *, &)
         else
           super
         end
       end
-      # rubocop:enable Style/ArgumentsForwarding
 
       def respond_to_missing?(method_name, include_private = false)
         (method_name.to_s.end_with?("=") && attribute_exist?(method_name)) ||

data/lib/lutaml/model/union.rb

@@ -131,7 +131,8 @@ module Lutaml
 
           def validate_members!(members)
             unless members.is_a?(::Array) && !members.empty?
-              raise ArgumentError, "union type must be a non-empty array of types"
+              raise ArgumentError,
+                    "union type must be a non-empty array of types"
             end
 
             resolved = members.map { |member| resolve_member!(member) }
@@ -166,7 +167,9 @@ module Lutaml
             return :no_match if keys.nil? || keys.empty?
 
             field_names = member_field_names(member, format, register)
-            return :no_match unless keys.all? { |key| field_names.include?(key) }
+            return :no_match unless keys.all? do |key|
+              field_names.include?(key)
+            end
 
             # Plain-Ruby assignment (format nil) builds straight from the
             # attribute hash, mirroring how non-union model attributes accept

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.18"
+    VERSION = "0.9.1"
   end
 end

data/lib/lutaml/xml/mapping_rule.rb

@@ -183,6 +183,34 @@ module Lutaml
         result
       end
 
+      # Match names an attribute rule consumes during parsing, mirroring how
+      # serialization qualifies the same attribute (resolve_namespace):
+      # a rule serialized with a prefix matches only attributes in its
+      # namespace; a rule serialized unprefixed matches only namespace-less
+      # attributes.
+      #
+      # Performance: memoized on the rule with zero-allocation cache hits.
+      # The inputs are constant for a given rule, register and parent model,
+      # so every element of a collection reuses the first resolution.
+      def attribute_match_names(attr, register, parent_ns_class, form_default,
+                                default_namespace)
+        if defined?(@_amn_names) && @_amn_register == register &&
+            @_amn_parent_ns == parent_ns_class &&
+            @_amn_form_default == form_default &&
+            @_amn_default_ns == default_namespace
+          return @_amn_names
+        end
+
+        result = compute_attribute_match_names(attr, register, parent_ns_class,
+                                               form_default, default_namespace)
+        @_amn_register = register
+        @_amn_parent_ns = parent_ns_class
+        @_amn_form_default = form_default
+        @_amn_default_ns = default_namespace
+        @_amn_names = result
+        result
+      end
+
       def namespaced_name(parent_namespace = nil, name = self.name)
         if name.to_s == "lang"
           ::Lutaml::Model::Utils.blank?(prefix) ? name.to_s : "#{prefix}:#{name}"
@@ -274,6 +302,30 @@ module Lutaml
 
       private
 
+      # Extracted body of attribute_match_names for caching
+      def compute_attribute_match_names(attr, register, parent_ns_class,
+                                        form_default, default_namespace)
+        ns_info = resolve_namespace(
+          attr: attr,
+          register: register,
+          parent_ns_class: parent_ns_class,
+          form_default: form_default,
+        )
+        uri = ns_info[:uri]
+        # Schema-level attribute_form_default keeps the historical plain-name
+        # parse: dependents (e.g. ogc-gml) declare :qualified but their
+        # documents and expectations rely on unprefixed attributes parsing.
+        # Explicit namespaces, type namespaces and explicit form: rules
+        # mirror serialization strictly.
+        strict_match = uri && ns_info[:prefix] &&
+          !ns_info[:unqualified_same_ns] && !ns_info[:via_schema_default]
+        if strict_match
+          ["#{uri}:#{name}"].freeze
+        else
+          namespaced_names(default_namespace)
+        end
+      end
+
       # Extracted body of namespaced_names for caching
       def compute_namespaced_names(parent_namespace)
         if multiple_mappings?
@@ -427,7 +479,9 @@ form_default = :unqualified)
         # When schema specifies attributeFormDefault="qualified", attributes
         # must be qualified (prefixed) with the parent element's namespace
         if form_default == :qualified && parent_ns_class
-          return build_namespace_result_from_class(parent_ns_class)
+          result = build_namespace_result_from_class(parent_ns_class)
+          result[:via_schema_default] = true
+          return result
         end
 
         # 4. No namespace (W3C default for unprefixed attributes)

data/lib/lutaml/xml/model_transform.rb

@@ -509,8 +509,13 @@ _effective_register)
           local_name = rn[(last_colon_index + 1)..]
 
           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).
+            # A namespace-less, prefix-less attribute cannot belong to the
+            # rule's namespace, so it must not satisfy the fallback
+            # (lutaml-model#744). Attributes with undeclared prefixes keep
+            # their prefix in the raw name and stay eligible below.
+            next false if attr.namespace.nil? &&
+              attr.namespace_prefix.nil? && !attr.name.include?(":")
+
             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)
@@ -544,9 +549,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?
 
@@ -879,6 +889,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/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/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/lutaml-model.gemspec

@@ -18,7 +18,10 @@ Gem::Specification.new do |spec|
 
   spec.bindir = "exe"
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+  # lib/ uses anonymous argument forwarding in call position, which parses
+  # only on Ruby 3.2+ (verified: 6 files fail to parse on 3.1). Without this
+  # floor, bundler resolves 0.8.x on 3.1 and it dies at require time.
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the