lutaml-model 0.8.140 → 0.8.142

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4340bd1bf4b75d088acb5a60a68073d2980d419fe5c7f59412966956a58e377
-  data.tar.gz: 829a741bc56fa070059d8198887cc51051859f64a2aeab747814c5f0d278356b
+  metadata.gz: 4ddbdf9b831babcd7fd6bd41314ea8b4f2352503f0302b2420942d9d144dc0bb
+  data.tar.gz: 4704a4bac05aef07a9a0a0a939180cd10d15ad4a8ab086dc218b126c68f97d2f
 SHA512:
-  metadata.gz: 14cda9bfd53830559db4848694f3118289958108e17f9445a079c585c8aed5f637878d4b1a0b4f232f1dca8d12100f4d56d73bb8289d2e73cd625a42682c90df
-  data.tar.gz: 124577fb5f037a6dea46e3da4f409713fadcc2ca2398e34a578d47230be5651274d3eabac7342fc708b2939c59d56f4248bfe97da88cc39dddce509cdffc83ef
+  metadata.gz: 817089bc912e7a85d912ecdffc09e8d894cadb3ca416450f6b5cab6d3b2463e4d9210ccf8ca0af1710a4de088562ef5628ec5896ff9585dc0ad6798444897a77
+  data.tar.gz: b1196728958dfc2e8be4ed6da1a70c4b5e09079c7c1d3940398e4c1c97adbd5bfa34d74a829ae51c9ad8a85d09ddcad5028050eca1de432f897b98fbdce5ff60

data/docs/PERFORMANCE_METHODOLOGY.md

@@ -328,8 +328,9 @@ end
 ```
 
 **Invalidation:** `finalize()` clears all caches before setting `@finalized`.
-This handles the case where `deep_dup` copies a finalized mapping, then the
-child class adds its own mappings and re-finalizes.
+This handles the case where a finalized mapping is copied into a child class
+(eagerly, or on first write under the inherited-state copy-on-write scheme),
+then the child adds its own mappings and re-finalizes.
 
 ```ruby
 def finalize(mapper_class)
@@ -429,6 +430,31 @@ classes caused 2-5x time regression despite reducing allocations.
 **Rule:** Keep caching inline with `@ivar` access. Guard specs that exercise
 the code path (not the cache implementation) are the correct tradeoff.
 
+### Pattern G: Copy-on-Write Inherited State
+
+**What happened:** every subclass used to `deep_dup` its parent's mappings,
+attributes, choices and register records at inheritance time — about 272
+allocations for a two-attribute parent, paid whether or not the subclass ever
+declared anything of its own.
+
+**Now:** a subclass shares the parent's structures by reference. A 2-bit
+status register per structure (`mappings`, `attributes`, `choices`,
+`registers`) records whether it is still inherited-shared or already owned,
+and whether the owned copy is itself shared with a further descendant. The
+first DSL write on the child forks that one structure (deep-dupping it and
+invalidating the merged-attribute cache); reads keep using the parent's
+objects. `choices` fork eagerly because imports mutate them in place.
+
+A DSL write on the parent forks the parent's own copy instead of mutating the
+structure its children share, so an already-defined child keeps exactly the
+state it inherited — the same snapshot semantics the eager copy provided, at
+none of the up-front cost.
+
+**Rule:** never mutate one of these structures directly. Go through the
+fork accessor (`lutaml_cow_fork!`, `lutaml_cow_mapping_for_dsl!`,
+`register_record_for_dsl!`); a bare `<<` on an inherited hash or array
+mutates the whole ancestry.
+
 ---
 
 ## 7. Profiling Guide
@@ -564,11 +590,14 @@ name, unprefixed name, or through the default namespace. Any optimization
 that changes the matching loop must preserve all three match paths. Test
 with Uniword (10+ sub-namespaces) and XMI (namespace aliases).
 
-### Pitfall 4: deep_dup + Finalize Cache Interaction
+### Pitfall 4: Inherited-State Copies + Finalize Cache Interaction
 
-**What happened:** `deep_dup` copied a finalized mapping, including its
+**What happened:** an inherited copy of a finalized mapping carried its
 frozen caches. The child class then added new mappings, but the cached
-elements/attributes were stale.
+elements/attributes were stale. (The copy used to be an eager `deep_dup` on
+every subclass; it is now copy-on-write — the parent's structures stay shared
+until the child first mutates one — but the cache hazard is the same at the
+moment the copy is materialized.)
 
 **Rule:** `finalize()` must clear all caches before setting `@finalized`.
 This ensures the first access after finalization builds correct caches.

data/lib/lutaml/model/choice.rb

@@ -128,9 +128,7 @@ register = nil)
 
         if register_id != :default
           # Non-default register: store in register-specific storage only
-          current_record = @model.register_records[register_id] ||= {
-            attributes: {}, choice_attributes: []
-          }
+          current_record = @model.register_record_for_dsl!(register_id)
           imported_attributes = Utils.deep_dup(model.attributes(register_id))
           imported_attributes.each_value do |attr|
             attr.options[:choice] = self

data/lib/lutaml/model/liquefiable.rb

@@ -14,7 +14,12 @@ module Lutaml
         def inherited(child)
           super
           child.register_class_if_liquid_defined
-          child.mappings = Utils.deep_dup(mappings) || {}
+          # Serialize models share mappings copy-on-write; a standalone
+          # Liquefiable class has no such state, so the eager copy is
+          # its only isolation from the parent.
+          unless child <= Lutaml::Model::Serialize
+            child.mappings = Utils.deep_dup(mappings) || {}
+          end
         end
 
         def register_class_if_liquid_defined
@@ -154,9 +159,15 @@ module Lutaml
         end
 
         def liquid(&block)
-          mappings[:liquid] ||= ::Lutaml::Model::Liquid::Mapping.new
-          mappings[:liquid].instance_eval(&block) if block
-          mappings[:liquid]
+          if self <= Lutaml::Model::Serialize
+            mapping = lutaml_cow_mapping_for_dsl!(:liquid) ||
+              ::Lutaml::Model::Liquid::Mapping.new
+            mappings[:liquid] = mapping
+          else
+            mapping = mappings[:liquid] ||= ::Lutaml::Model::Liquid::Mapping.new
+          end
+          mapping.instance_eval(&block) if block
+          mapping
         end
 
         def liquid_mappings

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

@@ -833,6 +833,7 @@ module Lutaml
           end
 
           attr = Attribute.new(name, type, options)
+          lutaml_cow_fork!(:attributes)
           @attributes[name] = attr
           @merged_attributes_cache = nil
           # Attributes can be declared after the model has been
@@ -853,6 +854,8 @@ module Lutaml
         # @return [Symbol] The attribute name
         def restrict(name, options = {})
           register_id = options.delete(:register) || Lutaml::Model::Config.default_register
+          lutaml_cow_fork!(:attributes)
+          lutaml_cow_fork!(:registers)
 
           if !@attributes.key?(name) && !register_record(register_id)&.dig(
             :attributes, name

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

@@ -22,7 +22,7 @@ module Lutaml
           end
 
           klass = ::Lutaml::Model::Config.mappings_class_for(format)
-          existing = mappings[format]
+          existing = lutaml_cow_mapping_for_dsl!(format)
           mappings[format] = if existing.nil? || !existing.is_a?(klass)
                                klass.new
                              else
@@ -476,9 +476,14 @@ module Lutaml
                     end
 
           formats.each do |format|
-            mappings[format] ||= Lutaml::KeyValue::Mapping.new(format)
-            mappings[format].instance_eval(&block)
-            mappings[format].finalize(self)
+            # The helper may replace @mappings mid-flight (CoW
+            # fork); bind it to a local before indexing, or the
+            # element assignment lands on the abandoned hash.
+            mapping = lutaml_cow_mapping_for_dsl!(format) ||
+              Lutaml::KeyValue::Mapping.new(format)
+            mappings[format] = mapping
+            mapping.instance_eval(&block)
+            mapping.finalize(self)
           end
         end
 
@@ -488,6 +493,7 @@ module Lutaml
         # @param block [Proc] The DSL block
         def rdf(&block)
           Lutaml::Model::FormatRegistry.rdf_formats.each do |format|
+            lutaml_cow_fork!(:mappings)
             mappings[format] = Lutaml::Rdf::Mapping.new
             mappings[format].instance_eval(&block)
           end

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

@@ -86,21 +86,159 @@ module Lutaml
           base.initialize_attrs(self)
         end
 
+        # Copy-on-write structure status. Two bits per structure
+        # (mappings, attributes, choices, registers): 0 = inherited and
+        # shared with the source class, 1 = owned and private (safe to
+        # mutate in place), 2 = owned but shared with subclasses (fork
+        # before mutating so they keep the pre-mutation state).
+        LUTAML_COW_STRUCTURES = %i[mappings attributes choices registers].freeze
+
         # Initialize class attributes from a source class
         #
         # @param source_class [Class] The source class to copy from
         def initialize_attrs(source_class)
-          @mappings = Utils.deep_dup(source_class.mappings) || {}
-          @attributes = Utils.deep_dup(source_class.class_attributes) || {}
-          @choice_attributes = deep_duplicate_choice_attributes(source_class)
-          @register_records = Utils.deep_dup(
-            source_class.register_records,
-          ) || ::Hash.new do |hash, key|
-                 hash[key] = { attributes: {}, choice_attributes: [] }
-               end
+          if source_class.equal?(self)
+            # A subclass that says `include Lutaml::Model::Serialize`
+            # again re-enters this hook with itself as the source. It
+            # already carries the state `inherited` installed, and the
+            # eager implementation re-copied that state; here it must
+            # survive untouched, so only a brand-new class initializes.
+            initialize_empty_attrs if @attributes.nil?
+          else
+            @mappings = source_class.mappings
+            @attributes = source_class.class_attributes
+            @choice_attributes = source_class.class_choice_attributes
+            @register_records = source_class.register_records
+            @lutaml_cow_status = 0
+            lutaml_cow_mark_ancestors_shared!(source_class)
+            # A choice binds its owning class and stamps itself onto
+            # the attribute options, so a subclass must rebind its
+            # choices to itself. Models without choices — the vast
+            # majority — keep sharing the empty array.
+            lutaml_cow_fork!(:choices) if @choice_attributes&.any?
+          end
           model(self)
         end
 
+        def initialize_empty_attrs
+          # `Liquefiable` may already have created the mapping store
+          # before this class included `Serialize`; that state is the
+          # class's own and must survive initialization.
+          @mappings ||= {}
+          @attributes ||= {}
+          @choice_attributes ||= []
+          @register_records ||= ::Hash.new do |hash, key|
+            hash[key] = { attributes: {}, choice_attributes: [] }
+          end
+          @lutaml_cow_status = Lutaml::Model::Serialize::Initialization
+            .lutaml_cow_status_for(1)
+        end
+
+        # Status value for every structure, encoded per structure
+        def self.lutaml_cow_status_for(state)
+          LUTAML_COW_STRUCTURES.each_index.sum do |i|
+            state << (i * 2)
+          end
+        end
+
+        def lutaml_cow_status(structure)
+          shift = LUTAML_COW_STRUCTURES.index(structure) * 2
+          ((@lutaml_cow_status || 0) >> shift) & 3
+        end
+
+        # Pack one structure's state back into the status word
+        def lutaml_cow_set_status!(structure, state)
+          shift = LUTAML_COW_STRUCTURES.index(structure) * 2
+          @lutaml_cow_status = ((@lutaml_cow_status || 0) & ~(3 << shift)) |
+            (state << shift)
+        end
+
+        # The structures this class inherited are about to gain a second
+        # referencer (the new subclass). Every ancestor whose current
+        # object for a structure is the object being shared must flip
+        # from owned-private to owned-shared, or its next in-place
+        # mutation would leak into the new subclass.
+        def lutaml_cow_mark_ancestors_shared!(source_class)
+          LUTAML_COW_STRUCTURES.each do |structure|
+            shared = lutaml_cow_structure(structure)
+            klass = source_class
+            loop do
+              if klass.lutaml_cow_structure(structure).equal?(shared) &&
+                  klass.lutaml_cow_status(structure) == 1
+                klass.lutaml_cow_set_status!(structure, 2)
+              end
+              break unless klass.is_a?(Class)
+
+              klass = klass.superclass
+              break unless klass.include?(Lutaml::Model::Serialize)
+            end
+          end
+        end
+
+        def lutaml_cow_structure(structure)
+          case structure
+          when :mappings then @mappings
+          when :attributes then @attributes
+          when :choices then @choice_attributes
+          when :registers then @register_records
+          end
+        end
+
+        private
+
+        # Replace a shared structure with a class-owned copy. The copy
+        # becomes the snapshot for every existing subclass, which is what
+        # keeps post-fork mutations invisible to them (the eager-copy
+        # semantics).
+        def lutaml_cow_fork!(structure)
+          return if lutaml_cow_status(structure) == 1
+
+          # The merged attribute view is built from the structures
+          # below; a replacement makes any cached merge stale.
+          @merged_attributes_cache = nil
+          case structure
+          when :mappings
+            # Entries are shared with the source class as well as the
+            # hash itself: a sibling inheriting the same object must
+            # not see this class's DSL. Copying every entry here is
+            # the lazy equivalent of the eager snapshot the previous
+            # implementation took in `inherited`.
+            @mappings = Utils.deep_dup(@mappings) || {}
+          when :attributes
+            @attributes = Utils.deep_dup(@attributes) || {}
+          when :choices
+            # Choice duplication rebinds Attribute objects through
+            # `attributes`, so the attributes fork must land first.
+            lutaml_cow_fork!(:attributes)
+            @choice_attributes = deep_duplicate_choice_attributes(self)
+          when :registers
+            @register_records = Utils.deep_dup(@register_records) ||
+              ::Hash.new do |hash, key|
+                hash[key] = { attributes: {}, choice_attributes: [] }
+              end
+          end
+          lutaml_cow_set_status!(structure, 1)
+        end
+
+        public
+
+        # Return the mapping object a format DSL may mutate. Forking
+        # the mappings structure copies every entry, so the object
+        # returned here is this class's own.
+        def lutaml_cow_mapping_for_dsl!(format)
+          lutaml_cow_fork!(:mappings)
+          @mappings[format]
+        end
+
+        # Return the register record a format DSL may mutate. The
+        # register store is copy-on-write, so write access forks it
+        # away from the parent class before handing out the record.
+        def register_record_for_dsl!(register_id)
+          lutaml_cow_fork!(:registers)
+          @register_records[register_id] ||= { attributes: {},
+                                               choice_attributes: [] }
+        end
+
         # Deep duplicate choice attributes from a source class
         #
         # @param source_class [Class] The source class
@@ -153,6 +291,13 @@ module Lutaml
           @attributes
         end
 
+        # Raw class-level choice attributes without register merging.
+        # Used by initialize_attrs during class inheritance.
+        # @return [Array] The raw choice attributes array
+        def class_choice_attributes
+          @choice_attributes
+        end
+
         # Get all choice attributes for this model
         #
         # Merges class-level choice attributes with register-specific choice attributes.
@@ -331,6 +476,7 @@ module Lutaml
         # @param max [Integer] Maximum number of choices
         # @param block [Proc] The choice definition block
         def choice(min: 1, max: 1, format: nil, &block)
+          lutaml_cow_fork!(:choices)
           @choice_attributes << Choice.new(self, min, max,
                                            format: format).tap do |c|
             c.instance_eval(&block)

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

@@ -57,6 +57,8 @@ module Lutaml
           end
 
           # Default register: merge into class-level storage
+          lutaml_cow_fork!(:attributes)
+          lutaml_cow_fork!(:choices)
           model.attributes.each_value { |attr| define_attribute_methods(attr) }
           @attributes.merge!(Utils.deep_dup(model.attributes))
           @choice_attributes.concat(deep_duplicate_choice_attributes(model))
@@ -81,8 +83,8 @@ module Lutaml
             next unless model.mappings.key?(format)
 
             klass = ::Lutaml::Model::Config.mappings_class_for(format)
-            @mappings[format] ||= klass.new
-            mapping = @mappings[format]
+            mapping = lutaml_cow_mapping_for_dsl!(format) || klass.new
+            @mappings[format] = mapping
             if mapping.is_a?(Mapping)
               mapping.import_model_mappings(model,
                                             register_id)
@@ -115,6 +117,8 @@ module Lutaml
         # @param model [Class] The model to import from
         # @param register_id [Symbol] The register context (must be non-default)
         def register_only_import_model_attributes(model, register_id)
+          lutaml_cow_fork!(:registers)
+          lutaml_cow_fork!(:choices)
           model.attributes(register_id).each_value do |attr|
             define_attribute_methods(attr, register_id)
           end
@@ -166,6 +170,7 @@ module Lutaml
         # resolution attempt ran — deferred_imports_pending? compares
         # against it to skip re-resolution on stable sets.
         def record_import_attempt(register_id)
+          lutaml_cow_fork!(:registers)
           # Raw stores only — the lazy attributes() re-enters
           # ensure_imports! and, when @models_imported was just set to
           # false (unresolved imports), cycles through this very
@@ -199,6 +204,7 @@ module Lutaml
 
         def ensure_model_imports!(register_id = nil)
           register_id ||= Lutaml::Model::Config.default_register
+          lutaml_cow_fork!(:registers)
           @models_imported = {} if @models_imported.nil? || @models_imported == false
           return if @models_imported[register_id] || Utils.present?(@register_records[register_id][:attributes])
 
@@ -236,6 +242,7 @@ module Lutaml
         # @param register_id [Symbol, nil] The register context
         def ensure_choice_imports!(register_id = nil)
           register_id ||= Lutaml::Model::Config.default_register
+          lutaml_cow_fork!(:registers)
           @choices_imported = {} if @choices_imported.nil? || @choices_imported == false
           return if @choices_imported[register_id] || Utils.present?(@register_records[register_id][:choice_attributes])
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.140"
+    VERSION = "0.8.142"
   end
 end

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

@@ -82,7 +82,7 @@ module Lutaml
             # 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)
+              record_schema_location(instance, node, model_class, register)
             end
             children.each do |child|
               child.lutaml_parent = instance
@@ -108,7 +108,10 @@ module Lutaml
 
           # The interpretive parse stores the root's xsi:schemaLocation
           # verbatim (set_schema_location); the writer re-emits it.
-          def record_schema_location(instance, node)
+          def record_schema_location(instance, node, model_class, register)
+            xml_mapping = model_class.mappings_for(:xml, register)
+            return if xml_mapping&.schema_location_mapped?(register)
+
             schema_loc = node.attributes.each_value.find do |a|
               a.name.to_s.split(":", 2).last == "schemaLocation"
             end

data/lib/lutaml/xml/mapping.rb

@@ -1455,6 +1455,18 @@ module Lutaml
         end
       end
 
+      # Whether the model maps the engine-reserved schemaLocation name
+      # itself (the XSD schema objects map it as a plain XSD attribute).
+      # Raw xsi:schemaLocation capture must stay out of the way, or the
+      # writer re-emits the value beside the mapped attribute (#1042).
+      def schema_location_mapped?(register_id = nil)
+        mapping_attributes_hash(register_id).each_value.any? do |rule_or_array|
+          Array(rule_or_array).any? do |rule|
+            rule.name.to_s == "schemaLocation"
+          end
+        end
+      end
+
       # Raw hash access for inheritance and deep_dup operations.
       # Callers may mutate the returned hash (e.g., setting keys).
       def elements_hash

data/lib/lutaml/xml/model_transform.rb

@@ -301,7 +301,7 @@ module Lutaml
         set_instance_ordering(instance, doc, ordered_option,
                               mixed_content_option, xml_mapping,
                               instance_is_serialize)
-        set_schema_location(instance, doc)
+        set_schema_location(instance, doc, xml_mapping, effective_register)
 
         defaults_used = []
 
@@ -511,11 +511,9 @@ module Lutaml
       end
 
       # #1031: wildcard attribute families. After the explicit attribute
-      # rules have consumed their names, every remaining attribute
-      # matching the rule's pattern lands in the target Hash — names
-      # claimed by explicit rules never leak into it. The key is the name
-      # as written, prefix included: keyed by its local name, xlink:href
-      # would serialize back as a plain href attribute.
+      # rules have consumed their names, every remaining unprefixed
+      # attribute matching the rule's pattern lands in the target Hash —
+      # names claimed by explicit rules never leak into it.
       def apply_all_attributes_deserialization(doc, instance, xml_mapping)
         rule = xml_mapping.all_attributes_rule
         return if rule.nil?
@@ -526,9 +524,8 @@ module Lutaml
         claimed = attribute_names_claimed_by_rules(xml_mapping)
         remainder = {}
         element.attributes.each_value do |attr|
-          next if claimed.include?(attr.unprefixed_name.to_s)
-
-          name = attr.name.to_s
+          name = attr.unprefixed_name.to_s
+          next if claimed.include?(name)
           next if rule.matching && !rule.matching.match?(name)
 
           remainder[name] = attr.value
@@ -588,7 +585,9 @@ instance_is_serialize = nil)
         end
       end
 
-      def set_schema_location(instance, doc)
+      def set_schema_location(instance, doc, xml_mapping, register)
+        return if xml_mapping&.schema_location_mapped?(register)
+
         schema_location = doc.attributes.values.find do |a|
           a.unprefixed_name == "schemaLocation"
         end

data/lib/lutaml/xml/namespace_collector.rb

@@ -68,7 +68,7 @@ module Lutaml
           if instance_rule
             attr_def = collection.class.attributes[instance_rule.to]
             if attr_def
-              instance_type = attr_def.type(@register)
+              instance_type = attr_def.type(effective_register_for(collection.class))
               if instance_type.is_a?(Class) &&
                   instance_type < Lutaml::Model::Serialize
                 instance_mapping = instance_type.mappings_for(:xml)
@@ -241,6 +241,17 @@ module Lutaml
         end
       end
 
+      # The register a model class's own attribute types resolve in: the
+      # class's lutaml_default_register takes precedence over the ambient
+      # register, unless the ambient register is a derived context carrying
+      # substitutions (Register.resolve_for_child encodes that contract).
+      def effective_register_for(mapper_class)
+        return @register unless mapper_class.is_a?(Class)
+
+        (@register_for ||= {})[mapper_class] ||=
+          Lutaml::Model::Register.resolve_for_child(mapper_class, @register)
+      end
+
       # Internal collection method
       #
       # @param element [Object] the model instance (can be nil for type analysis)
@@ -277,6 +288,13 @@ module Lutaml
                          {}
                        end
 
+          # Attribute types belong to the model declaring them: a nested
+          # model with its own lutaml_default_register (an mml element
+          # inside an STS document) declares symbolic types only that
+          # register knows. Resolving them in the ambient register raises
+          # UnknownTypeError while collecting namespaces.
+          attribute_register = effective_register_for(mapper_class)
+
           # ==================================================================
           # PHASE 1: OWN NAMESPACE COLLECTION (for non-type-only models)
           # ==================================================================
@@ -370,7 +388,7 @@ module Lutaml
             attr_def = attributes[elem_rule.to]
             next unless attr_def
 
-            child_type = attr_def.type(@register)
+            child_type = attr_def.type(attribute_register)
             next unless child_type
 
             # Get child instance BEFORE adding Type ref
@@ -579,16 +597,9 @@ module Lutaml
               # Get child's mapper_class and mapping
               attr_def = attributes[matching_rule.to]
               if attr_def
-                # Resolve type using child model's register context
+                # Resolve type using the owning model's register context
                 mapper_class = options[:mapper_class]
-                child_register = if mapper_class
-                                   (@register_for ||= {})[mapper_class] ||=
-                                     Lutaml::Model::Register.resolve_for_child(
-                                       mapper_class, @register
-                                     )
-                                 else
-                                   @register
-                                 end
+                child_register = effective_register_for(mapper_class)
                 child_type = attr_def.type(child_register)
                 if child_type.is_a?(Class) && child_type < Lutaml::Model::Serialize
                   child_mapping = child_type.mappings_for(:xml)

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

@@ -19,7 +19,7 @@ module Lutaml
             namespace Lutaml::Xml::Schema::XsdNamespace
 
             map_attribute :id, to: :id
-            map_attribute "schemaLocation", to: :schema_path
+            map_attribute :schemaLocation, to: :schema_path
             map_element :group, to: :group
             map_element :annotation, to: :annotation
             map_element :simpleType, to: :simple_type

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

@@ -107,6 +107,7 @@ module Lutaml
         # @param block [Proc] The DSL block
         def process_mapping(format, *args, &block)
           if format == :xml && args.any? && args.first.is_a?(Class) && args.first < Lutaml::Xml::Mapping
+            lutaml_cow_fork!(:mappings)
             process_xml_mapping_class_inheritance(args.first, &block)
           else
             super

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

@@ -23,7 +23,7 @@ module Lutaml
         #
         # @param register [Symbol, nil] The register context
         def ensure_format_mapping_imports!(register = nil)
-          mappings[:xml]&.ensure_mappings_imported!(register)
+          lutaml_cow_mapping_for_dsl!(:xml)&.ensure_mappings_imported!(register)
         end
 
         # Check for conflicting sort configurations with XML ordered mapping

data/spec/lutaml/model/inherited_state_isolation_spec.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative "../../spec_helper"
+
+# Pin the inheritance-state isolation contract between a model class, its
+# superclass and its siblings. These are the semantics the eager copy in
+# `initialize_attrs` has always provided; they must hold for any
+# copy-on-write replacement of that copy.
+RSpec.describe "inherited model state isolation" do
+  let(:parent) do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :size, :integer
+
+      xml do
+        element "parent"
+        map_attribute "name", to: :name
+        map_element "size", to: :size
+      end
+    end
+    stub_const("IsoParent", klass)
+    klass
+  end
+
+  it "gives the child the parent's attributes and mappings immediately" do
+    child = Class.new(parent)
+    stub_const("IsoChildSeen", child)
+
+    expect(IsoChildSeen.attributes.key?(:name)).to be(true)
+    expect(IsoChildSeen.attributes.key?(:size)).to be(true)
+    expect(IsoChildSeen.mappings[:xml].elements_hash).not_to be_empty
+  end
+
+  it "hides a child's attribute declaration from the parent" do
+    child = Class.new(parent) do
+      attribute :extra, :string
+    end
+    stub_const("IsoChildExtra", child)
+
+    expect(IsoChildExtra.attributes.key?(:extra)).to be(true)
+    expect(parent.attributes.key?(:extra)).to be(false)
+  end
+
+  it "hides a child's mapping declaration from the parent" do
+    child = Class.new(parent) do
+      attribute :extra, :string
+      xml do
+        map_element "extra", to: :extra
+      end
+    end
+    stub_const("IsoChildMapping", child)
+
+    model = child.new(name: "x", extra: "e")
+    expect(model.to_xml).to include("<extra>e</extra>")
+    expect(parent.mappings[:xml].elements_hash.key?("extra")).to be(false)
+  end
+
+  it "hides a parent attribute declared after subclassing from the child" do
+    child = Class.new(parent)
+    stub_const("IsoChildLateParent", child)
+
+    parent.attribute :late, :string
+
+    expect(parent.attributes.key?(:late)).to be(true)
+    expect(child.attributes.key?(:late)).to be(false)
+  end
+
+  it "hides a parent mapping declared after subclassing from the child" do
+    child = Class.new(parent) do
+      attribute :late_element, :string
+    end
+    stub_const("IsoChildLateMapping", child)
+
+    parent.xml do
+      map_element "late_element", to: :late_element
+    end
+
+    expect(parent.mappings[:xml].elements_hash.key?("late_element")).to be(true)
+    expect(child.mappings[:xml].elements_hash.key?("late_element")).to be(false)
+  end
+
+  it "isolates restrict between parent, child and sibling" do
+    child_a = Class.new(parent)
+    stub_const("IsoRestrictA", child_a)
+    child_b = Class.new(parent)
+    stub_const("IsoRestrictB", child_b)
+
+    child_a.restrict :name, default: "a-default"
+    parent.restrict :size, default: 42
+
+    expect(parent.attributes[:name].default).to eq(IsoRestrictB.attributes[:name].default)
+    expect(IsoRestrictA.attributes[:name].default).to eq("a-default")
+    expect(IsoRestrictB.attributes[:size].default).not_to eq(42)
+    expect(IsoRestrictA.attributes[:size].default).not_to eq(42)
+  end
+
+  it "isolates choice declarations from the parent" do
+    child = Class.new(parent) do
+      choice(min: 0, max: 1) do
+        attribute :a, :string
+        attribute :b, :string
+      end
+    end
+    stub_const("IsoChoiceChild", child)
+
+    expect(child.choice_attributes.size).to eq(1)
+    expect(parent.choice_attributes).to be_empty
+  end
+
+  it "isolates a register-only import from the parent" do
+    source = Class.new(Lutaml::Model::Serializable) do
+      attribute :imported, :string
+    end
+    stub_const("IsoImportSource", source)
+
+    child = Class.new(parent) do
+      xml do
+        element "child"
+        map_attribute "name", to: :name
+      end
+      import_model IsoImportSource, :custom_reg
+    end
+    stub_const("IsoImportChild", child)
+
+    expect(child.register_record(:custom_reg)[:attributes].key?(:imported))
+      .to be(true)
+    expect(parent.register_record(:custom_reg)[:attributes]).to be_empty
+    expect(source.attributes.key?(:imported)).to be(true)
+  end
+
+  it "keeps a default-register import out of the parent" do
+    source = Class.new(Lutaml::Model::Serializable) do
+      attribute :def_imported, :string
+    end
+    stub_const("IsoImportDefaultSource", source)
+
+    child = Class.new(parent) do
+      import_model IsoImportDefaultSource
+    end
+    stub_const("IsoImportDefaultChild", child)
+
+    expect(child.attributes.key?(:def_imported)).to be(true)
+    expect(parent.attributes.key?(:def_imported)).to be(false)
+    expect(source.attributes.key?(:def_imported)).to be(true)
+  end
+
+  it "serializes a trio byte-identically to independently declared models" do
+    child = Class.new(parent) do
+      attribute :note, :string
+      xml do
+        map_element "note", to: :note
+      end
+    end
+    stub_const("IsoTrioChild", child)
+    sibling = Class.new(parent) do
+      attribute :flag, :string
+      xml do
+        map_element "flag", to: :flag
+      end
+    end
+    stub_const("IsoTrioSibling", sibling)
+
+    inherited = child.from_xml("<parent name=\"n\"><size>1</size><note>x</note></parent>")
+    standalone = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :size, :integer
+      attribute :note, :string
+      xml do
+        element "parent"
+        map_attribute "name", to: :name
+        map_element "size", to: :size
+        map_element "note", to: :note
+      end
+    end
+    stub_const("IsoTrioStandalone", standalone)
+
+    expect(inherited.to_xml).to include("<size>1</size>")
+    expect(inherited.to_xml).to include("<note>x</note>")
+    expect(standalone.from_xml(inherited.to_xml).to_xml).to eq(inherited.to_xml)
+    expect(sibling.from_xml("<parent name=\"s\"><flag>1</flag></parent>").to_xml)
+      .to include("<flag>1</flag>")
+  end
+
+  it "keeps grandparent chains isolated in both directions" do
+    mid = Class.new(parent) do
+      attribute :mid_attr, :string
+    end
+    stub_const("IsoMid", mid)
+    leaf = Class.new(mid)
+    stub_const("IsoLeaf", leaf)
+
+    parent.attribute :gp_late, :string
+    mid.attribute :mid_late, :string
+
+    expect(leaf.attributes.key?(:name)).to be(true)
+    expect(leaf.attributes.key?(:mid_attr)).to be(true)
+    expect(leaf.attributes.key?(:gp_late)).to be(false)
+    expect(leaf.attributes.key?(:mid_late)).to be(false)
+    expect(mid.attributes.key?(:gp_late)).to be(false)
+    expect(parent.attributes.key?(:mid_attr)).to be(false)
+  end
+end

data/spec/lutaml/model/map_all_attributes_spec.rb

@@ -87,28 +87,6 @@ RSpec.describe "map_all_attributes" do
     expect(model.other_attributes).to eq("zeta" => "1")
   end
 
-  it "keeps a prefixed attribute's prefix through a round-trip" do
-    xml = '<mn xmlns:xlink="http://www.w3.org/1999/xlink" name="x" ' \
-          'data-title="T" xlink:href="#t"/>'
-    klass = Class.new(Lutaml::Model::Serializable) do
-      attribute :name, :string
-      attribute :other_attributes, :hash
-
-      xml do
-        element "mn"
-        map_attribute "name", to: :name
-        map_all_attributes to: :other_attributes
-      end
-    end
-    stub_const("MapAllPrefixedModel", klass)
-
-    model = klass.from_xml(xml)
-
-    expect(model.other_attributes).to eq("data-title" => "T", "xlink:href" => "#t")
-    expect(model.to_xml).to include('xlink:href="#t"')
-    expect(model.to_xml).not_to include(' href="#t"')
-  end
-
   it "is inherited by a subclass along with the other mappings" do
     stub_const("MapAllAttributesChild", Class.new(stubbed))
 

data/spec/lutaml/xml/namespace_collector_child_register_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# A nested model may declare its own `lutaml_default_register` (mml does:
+# every MathML element class resolves its symbolic child types in the
+# per-version MML context). Namespace collection walks the child's XML
+# mapping; it must resolve the child's *own* attribute types in the
+# child's register, not in the ambient (parent) register.
+RSpec.describe "NamespaceCollector nested child model registers" do
+  before do
+    ctx = Lutaml::Model::GlobalContext.create_context(
+      id: :nscollectorchild, registry: Lutaml::Model::TypeRegistry.new,
+    )
+    ctx.registry.register(:part, widget_part_class)
+  end
+
+  let(:widget_part_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      xml do
+        element "part"
+      end
+    end
+  end
+
+  # The symbolic attribute type is declared on a base class; the concrete
+  # model is a subclass that carries the register hook. This mirrors
+  # Mml::V3::Math < Mml::CommonElements.
+  let(:widget_class) do
+    Class.new(widget_base_class) do
+      def self.lutaml_default_register
+        :nscollectorchild
+      end
+    end
+  end
+
+  let(:widget_base_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :part_value, :part, collection: true
+
+      xml do
+        element "widget"
+        map_element "part", to: :part_value
+      end
+    end
+  end
+
+  let(:host_class) do
+    widget = widget_class
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :widget, widget
+
+      xml do
+        element "host"
+        map_element "widget", to: :widget
+      end
+    end
+  end
+
+  let(:instance) do
+    host_class.from_xml("<host><widget><part/></widget></host>")
+  end
+
+  it "resolves the child's symbolic attribute types in the child's register" do
+    collector = Lutaml::Xml::NamespaceCollector.new(:default)
+
+    expect do
+      collector.collect(instance, host_class.mappings_for(:xml))
+    end.not_to raise_error
+  end
+end

data/spec/lutaml/xml/schema/xsd/redefine_schema_location_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../../../../spec_helper"
+require "open3"
+require "lutaml/xml/schema/xsd"
+
+# #1042: the XSD schema-object classes map the plain `schemaLocation`
+# attribute — an XSD attribute on xs:redefine, not xsi:schemaLocation.
+# The class used to warn about its own mapping ("handled by default"),
+# and the engine's raw xsi capture then re-emitted the value as
+# xsi:schemaLocation beside the mapped attribute.
+RSpec.describe "Xsd::Redefine schemaLocation" do
+  let(:xsd) do
+    <<~XSD
+      <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+        <xsd:redefine schemaLocation="base.xsd">
+          <xsd:group name="g">
+            <xsd:choice><xsd:element name="e1"/></xsd:choice>
+          </xsd:group>
+        </xsd:redefine>
+      </xsd:schema>
+    XSD
+  end
+
+  it "reads schemaLocation into schema_path" do
+    doc = Lutaml::Xml::Schema::Xsd.parse(xsd)
+
+    expect(doc.redefine.first.schema_path).to eq("base.xsd")
+  end
+
+  it "round-trips it as the plain attribute without an xsi copy" do
+    xml = Lutaml::Xml::Schema::Xsd.parse(xsd).to_xml
+
+    expect(xml).to include('schemaLocation="base.xsd"')
+    expect(xml).not_to include("xsi:schemaLocation")
+  end
+
+  it "does not warn while defining its own mapping" do
+    probe = 'require "lutaml/model"; require "lutaml/xml/schema/xsd"; ' \
+            "Lutaml::Xml::Schema::Xsd::Redefine"
+
+    _out, err, status = Open3.capture3(RbConfig.ruby, "-I", "lib", "-e", probe)
+
+    expect(status).to be_success, err
+    expect(err).not_to include("handled by default")
+  end
+
+  it "still captures xsi:schemaLocation on models that do not map it" do
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      xml do
+        element "r"
+        map_attribute "name", to: :name
+      end
+    end
+    stub_const("AutoSchemaLocationModel", model)
+
+    parsed = AutoSchemaLocationModel.from_xml(
+      '<r xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' \
+      'name="n" xsi:schemaLocation="urn:a a.xsd"/>',
+    )
+
+    expect(parsed.raw_schema_location).to eq("urn:a a.xsd")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.140
+  version: 0.8.142
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1782,6 +1782,7 @@ files:
 - spec/lutaml/model/import_registry_spec.rb
 - spec/lutaml/model/included_spec.rb
 - spec/lutaml/model/inheritance_spec.rb
+- spec/lutaml/model/inherited_state_isolation_spec.rb
 - spec/lutaml/model/json_adapter_spec.rb
 - spec/lutaml/model/json_spec.rb
 - spec/lutaml/model/json_state_nesting_spec.rb
@@ -2001,6 +2002,7 @@ files:
 - spec/lutaml/xml/namespace_aware_parsing_spec.rb
 - spec/lutaml/xml/namespace_backward_compatibility_spec.rb
 - spec/lutaml/xml/namespace_bound_element_roundtrip_spec.rb
+- spec/lutaml/xml/namespace_collector_child_register_spec.rb
 - spec/lutaml/xml/namespace_constant_spec.rb
 - spec/lutaml/xml/namespace_force_prefix_spec.rb
 - spec/lutaml/xml/namespace_format_preservation_spec.rb
@@ -2060,6 +2062,7 @@ files:
 - spec/lutaml/xml/schema/xsd/list_simple_type_spec.rb
 - spec/lutaml/xml/schema/xsd/mapping_integrity_spec.rb
 - spec/lutaml/xml/schema/xsd/namespace_uri_remapping_spec.rb
+- spec/lutaml/xml/schema/xsd/redefine_schema_location_spec.rb
 - spec/lutaml/xml/schema/xsd/schema_helper_methods_spec.rb
 - spec/lutaml/xml/schema/xsd/schema_mapping_spec.rb
 - spec/lutaml/xml/schema/xsd/schema_validator_spec.rb