lutaml-model 0.8.19 → 0.8.23

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,33 @@ 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]
+        # Per W3C, an unprefixed attribute is in NO namespace regardless of
+        # the element's namespace. The qualified alias is only legitimate
+        # under schema-level attribute_form_default :qualified — the
+        # via_schema_default leniency (preserves ogc-gml's srsName handling
+        # under :qualified schema defaults). Without this gate, a plain
+        # attribute rule on an element-namespaced class inherits the
+        # element's namespace as default_namespace and steals a
+        # namespaced-sibling attribute whose local name matches (lutaml-model#758).
+        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?
@@ -413,7 +468,8 @@ form_default = :unqualified)
         end
 
         # 2. Type-level namespace
-        if attr && (type_ns_class = attr.type_namespace_class(register))
+        if attr && (type_ns_class = attr.type_namespace_class(register)) &&
+            type_ns_class != :blank
           result = build_namespace_result_from_class(type_ns_class)
           # CRITICAL W3C FLAG: Mark when attribute is in same namespace as parent with :unqualified
           # Serialization code will check this to omit prefix per attributeFormDefault
@@ -427,7 +483,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)
@@ -490,7 +548,8 @@ form_default = :unqualified)
         end
 
         # 4. Type-level namespace
-        if attr && (type_ns_class = attr.type_namespace_class(register))
+        if attr && (type_ns_class = attr.type_namespace_class(register)) &&
+            type_ns_class != :blank
           # Check if Type namespace matches parent default namespace
           # If so, use parent's namespace with parent's actual prefix
           if type_ns_class.uri == parent_ns_uri && parent_ns_class

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)
@@ -263,6 +258,18 @@ effective_register = nil, instance_is_serialize = nil)
           end
         end
 
+        # lutaml-model#765: several plain element rules may target one
+        # collection attribute (spelling tolerance, e.g. editorial-group vs
+        # editorialgroup). The first rule of such a group performs matching
+        # widened to every spelling so content merges in document order;
+        # the remaining rules are no-ops so their assignment cannot
+        # silently overwrite the merged value.
+        # Grouping is cached on the mapping DSL (per register); only the
+        # collection filter runs here.
+        grouped_plain_rules = xml_mapping.plain_element_rules_by_attr(
+          effective_register,
+        )
+
         mappings.each do |rule|
           # Performance: Cache rule properties accessed multiple times
           rule.name
@@ -273,6 +280,11 @@ effective_register = nil, instance_is_serialize = nil)
           attr = attribute_for_rule(rule)
           next if attr&.derived?
 
+          if (group = grouped_plain_rules[rule_to]) &&
+              group.size > 1 && attr&.collection? && !group.first.equal?(rule)
+            next
+          end
+
           raise "Attribute '#{rule_to}' not found in #{context}" unless valid_rule?(
             rule, attr
           )
@@ -290,6 +302,26 @@ effective_register = nil, instance_is_serialize = nil)
                     doc.root.inner_xml
                   elsif rule.content_mapping?
                     rule.cdata ? doc.cdata : doc.text
+                  elsif (group = grouped_plain_rules[rule_to]) &&
+                      group.size > 1 && attr&.collection?
+                    # First rule of a #765 group: match every spelling of
+                    # the group so the children merge in document order.
+                    if child_names_set &&
+                        group.drop(1).none? do |s|
+                          child_matches_rule?(s, child_names_set,
+                                              default_namespace)
+                        end && !child_matches_rule?(rule, child_names_set,
+                                                    default_namespace)
+                      ::Lutaml::Model::UninitializedClass.instance
+                    else
+                      extra_names = group.drop(1).flat_map do |s|
+                        resolve_rule_names_with_type(s, attr, new_opts,
+                                                     effective_register,
+                                                     attr&.type(effective_register))
+                      end
+                      value_for_rule(session, rule, new_opts, attr,
+                                     extra_names)
+                    end
                   elsif child_names_set && !rule.attribute? &&
                       !child_matches_rule?(rule, child_names_set,
                                            default_namespace)
@@ -303,8 +335,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 +468,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 +506,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 +556,44 @@ _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,
+                         extra_rule_names = 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 +606,20 @@ _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
+        # lutaml-model#765: widened matching for the first rule of a
+        # shared-attribute group — children of sibling spellings must be
+        # selected too, in document order. Deduped: sibling resolution can
+        # yield the same spelling twice, and the child index would then
+        # return the same children again.
+        rule_names = rule_names.concat(extra_rule_names).uniq if extra_rule_names
 
         return value_for_xml_attribute(doc, rule, rule_names) if rule.attribute?
 
@@ -565,15 +638,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
@@ -604,6 +687,13 @@ _effective_register)
             children = nil # fall through to select for alias matching
           else
             children = indexed.flatten(1)
+            # #765 widened matching: rule_names spans several spellings, so
+            # the flatten above yields rule-name order; restore document
+            # order for the merged group.
+            if extra_rule_names
+              position = element_children.each_with_index.to_h
+              children = children.sort_by { |c| position[c] }
+            end
           end
         else
           children = nil
@@ -879,6 +969,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

@@ -326,7 +326,8 @@ compiled_rules, mapping, processed_text_nodes)
                              compiled_rules
                            end
 
-          emitted_counts = element_order_coverage(model_instance, compiled_rules)
+          emitted_counts = element_order_coverage(model_instance,
+                                                  compiled_rules)
 
           rules_to_apply.each do |rule|
             mapping_type = rule.option(:mapping_type)