lutaml-model 0.8.7 → 0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf72982044ef4dcc8a413bafe9432721faac7954f6cee3ff75446b3cf9af0016
-  data.tar.gz: 9c920d3cf43328d88cfd4be60cfd4b03dbf40b2c7f7d3e532d35518e3081014c
+  metadata.gz: 076bdbfb0836ad989e3fe90d5287d9662f35fb00492b6dfed0aef95db7296cdd
+  data.tar.gz: 1008556dd2eb02cd3aa08cffc2278f1952fab2d4c97af47a96eeea2b0975d622
 SHA512:
-  metadata.gz: d396accc65f1dff8a826baf62764e01f2217d20bff02ca3aee70d4dba7244df7c8577ff6f1d84fd3d97f93e7f8dcc87583d07a441398c691aaa90f5955799d73
-  data.tar.gz: 124d44d40a30dbe9ff896d7afc8eedfda5a66d6a06453d43901cbd6dffdcbab2f2f34234b9cebdd30326e0110678a3f346e35ed1d0e8553a896bf69af42b5a66
+  metadata.gz: e9019e0d1223841cc427b5ebe1c5e6afffa5f88b8abd9ab72fe521908ec43d431fc59bacc9054c50d3f190a436baae4047e12ad922db253b800554c4b1c93408
+  data.tar.gz: 33d5644f9275a211f45ea8d89a6bd371dab01b8140dfbd62a44c31496b33d09cda2c5ba7b03e361733e450d6186663fce61e449f80f51e1353ee4ec1a7dbfd5e

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-05-13 07:30:26 UTC using RuboCop version 1.86.0.
+# on 2026-05-14 09:40:04 UTC using RuboCop version 1.86.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -11,66 +11,27 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'lutaml-model.gemspec'
 
-# Offense count: 4
+# Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyle, IndentationWidth.
 # SupportedStyles: with_first_argument, with_fixed_indentation
 Layout/ArgumentAlignment:
   Exclude:
-    - 'lib/lutaml/xml/adapter/plan_based_builder.rb'
-    - 'lib/lutaml/xml/adapter/xml_parser.rb'
-    - 'lib/lutaml/xml/serialization/instance_methods.rb'
-    - 'spec/lutaml/xml/schema/compiler_spec.rb'
-
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: IndentationWidth.
-Layout/AssignmentIndentation:
-  Exclude:
-    - 'lib/lutaml/xml/adapter/xml_serializer.rb'
-
-# Offense count: 3
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyleAlignWith.
-# SupportedStylesAlignWith: either, start_of_block, start_of_line
-Layout/BlockAlignment:
-  Exclude:
-    - 'lib/lutaml/xml/serialization/format_conversion.rb'
-    - 'lib/lutaml/xml/xml_element.rb'
-
-# Offense count: 3
-# This cop supports safe autocorrection (--autocorrect).
-Layout/BlockEndNewline:
-  Exclude:
-    - 'lib/lutaml/xml/serialization/format_conversion.rb'
-    - 'lib/lutaml/xml/xml_element.rb'
-
-# Offense count: 6
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: Width, EnforcedStyleAlignWith, AllowedPatterns.
-# SupportedStylesAlignWith: start_of_line, relative_to_receiver
-Layout/IndentationWidth:
-  Exclude:
-    - 'lib/lutaml/xml/serialization/format_conversion.rb'
-    - 'lib/lutaml/xml/xml_element.rb'
+    - 'lib/lutaml/model/store.rb'
 
-# Offense count: 2981
+# Offense count: 2982
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 5
+# Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: AllowInHeredoc.
 Layout/TrailingWhitespace:
   Exclude:
-    - 'lib/lutaml/xml/adapter/plan_based_builder.rb'
-    - 'lib/lutaml/xml/adapter/xml_parser.rb'
-    - 'lib/lutaml/xml/adapter/xml_serializer.rb'
-    - 'lib/lutaml/xml/serialization/instance_methods.rb'
-    - 'spec/lutaml/xml/schema/compiler_spec.rb'
+    - 'lib/lutaml/model/store.rb'
 
 # Offense count: 21
 # Configuration parameters: AllowedMethods.
@@ -83,7 +44,7 @@ Lint/ConstantDefinitionInBlock:
     - 'spec/lutaml/xml/type_namespace_prefix_spec.rb'
     - 'spec/lutaml/xml/xml_space_type_spec.rb'
 
-# Offense count: 34
+# Offense count: 36
 # Configuration parameters: IgnoreLiteralBranches, IgnoreConstantBranches, IgnoreDuplicateElseBranch.
 Lint/DuplicateBranch:
   Enabled: false
@@ -184,12 +145,12 @@ Metrics/BlockLength:
 Metrics/BlockNesting:
   Max: 6
 
-# Offense count: 300
+# Offense count: 302
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 549
+# Offense count: 554
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 514
@@ -200,7 +161,7 @@ Metrics/ParameterLists:
   Max: 24
   MaxOptionalParameters: 5
 
-# Offense count: 251
+# Offense count: 253
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
@@ -292,7 +253,7 @@ RSpec/BeforeAfterAll:
 RSpec/ContextWording:
   Enabled: false
 
-# Offense count: 94
+# Offense count: 95
 # Configuration parameters: IgnoredMetadata.
 RSpec/DescribeClass:
   Enabled: false
@@ -303,7 +264,7 @@ RSpec/DescribeMethod:
     - 'spec/lutaml/xml/schema/xsd/schema_helper_methods_spec.rb'
     - 'spec/lutaml/xml/serializable_namespace_spec.rb'
 
-# Offense count: 1238
+# Offense count: 1246
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 68
@@ -378,7 +339,7 @@ RSpec/MultipleDescribes:
     - 'spec/lutaml/xml/namespace_resolution_strategy_spec.rb'
     - 'spec/lutaml/xml/xml_space_type_spec.rb'
 
-# Offense count: 1468
+# Offense count: 1482
 RSpec/MultipleExpectations:
   Max: 21
 
@@ -451,18 +412,6 @@ Security/MarshalLoad:
   Exclude:
     - 'scripts-xmi-profile/profile_xmi.rb'
 
-# Offense count: 4
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, ProceduralMethods, FunctionalMethods, AllowedMethods, AllowedPatterns, AllowBracesOnProceduralOneLiners, BracesRequiredMethods.
-# SupportedStyles: line_count_based, semantic, braces_for_chaining, always_braces
-# ProceduralMethods: benchmark, bm, bmbm, create, each_with_object, measure, new, realtime, tap, with_object
-# FunctionalMethods: let, let!, subject, watch
-# AllowedMethods: lambda, proc, it
-Style/BlockDelimiters:
-  Exclude:
-    - 'lib/lutaml/xml/serialization/format_conversion.rb'
-    - 'lib/lutaml/xml/xml_element.rb'
-
 # Offense count: 2
 # This cop supports unsafe autocorrection (--autocorrect-all).
 # Configuration parameters: AllowedMethods, AllowedPatterns.
@@ -508,13 +457,11 @@ Style/MixinUsage:
     - 'bench/bench_unitsml.rb'
     - 'bench/bench_xmi.rb'
 
-# Offense count: 3
+# Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
 Style/MultilineIfModifier:
   Exclude:
-    - 'lib/lutaml/xml/adapter/xml_parser.rb'
-    - 'lib/lutaml/xml/adapter/xml_serializer.rb'
-    - 'spec/lutaml/xml/schema/compiler_spec.rb'
+    - 'lib/lutaml/model/store.rb'
 
 # Offense count: 12
 # Configuration parameters: AllowedClasses.

data/lib/lutaml/model/attribute.rb

@@ -6,6 +6,7 @@ module Lutaml
       attr_reader :name, :options
 
       include CollectionHandler
+      include DeepDupable
 
       ALLOWED_OPTIONS = %i[
         raw
@@ -194,7 +195,7 @@ module Lutaml
                           end
 
         # If we don't have an actual Register object, fall back to standard resolution
-        result = if actual_register.respond_to?(:resolve_in_namespace)
+        result = if actual_register.is_a?(Lutaml::Model::Register)
                    actual_register.resolve_in_namespace(unresolved_type,
                                                         namespace_uri)
                  end
@@ -290,7 +291,7 @@ module Lutaml
       def required_value_set?(value)
         return true unless options[:required]
         return false if value.nil?
-        return false if value.respond_to?(:empty?) && value.empty?
+        return false if Utils.empty?(value)
 
         true
       end
@@ -573,7 +574,6 @@ instance_object = nil)
       end
 
       def model_instance?(value)
-        return false unless value.respond_to?(:class)
         return false unless @options[:ref_model_class]
 
         value.class.name == @options[:ref_model_class]
@@ -609,10 +609,8 @@ instance_object = nil)
         # These are never Serializable, so skip expensive can_serialize? and needs_conversion? checks
         # Skip if type has custom from_xml/from_json methods (defined on the class itself, not inherited)
         if resolved_type.is_a?(Class) && resolved_type < Lutaml::Model::Type::Value
-          has_custom_from_xml = resolved_type.respond_to?(:from_xml) &&
-            resolved_type.method(:from_xml).owner != Lutaml::Model::Type::Value
-          has_custom_from_json = resolved_type.respond_to?(:from_json) &&
-            resolved_type.method(:from_json).owner != Lutaml::Model::Type::Value
+          has_custom_from_xml = resolved_type.method(:from_xml).owner != Lutaml::Model::Type::Value
+          has_custom_from_json = resolved_type.method(:from_json).owner != Lutaml::Model::Type::Value
           return resolved_type.cast(value) unless has_custom_from_xml || has_custom_from_json
         end
 

data/lib/lutaml/model/attribute_validator.rb

@@ -56,7 +56,9 @@ module Lutaml
       def ensure_required?(value)
         return true unless attribute.options[:required]
         return false if value.nil?
-        return false if value.respond_to?(:empty?) && value.empty?
+        return false if value.is_a?(String) && value.empty?
+        return false if value.is_a?(Array) && value.empty?
+        return false if value.is_a?(Hash) && value.empty?
 
         true
       end

data/lib/lutaml/model/choice.rb

@@ -252,7 +252,7 @@ register = nil)
       def should_render_empty?(object, attribute)
         value = object.public_send(attribute.name)
         return false if Utils.uninitialized?(value)
-        return false unless Utils.empty?(value) || (value.respond_to?(:empty?) && value.empty?)
+        return false unless Utils.empty?(value)
         return false unless @format
 
         # Check if this attribute should render when empty

data/lib/lutaml/model/deep_dupable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    # Protocol module for objects that support deep duplication.
+    #
+    # Include this module in any class that needs custom deep-copy semantics
+    # beyond Ruby's default `dup`. Used by Utils.deep_dup to dispatch correctly
+    # via type checking instead of respond_to?.
+    module DeepDupable
+      def deep_dup
+        raise NotImplementedError, "#{self.class} must implement deep_dup"
+      end
+    end
+  end
+end

data/lib/lutaml/model/mapping/mapping.rb

@@ -1,6 +1,8 @@
 module Lutaml
   module Model
     class Mapping
+      include DeepDupable
+
       def initialize
         @mappings = []
         @listeners = {} # target => [Listener, ...]

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -1,6 +1,8 @@
 module Lutaml
   module Model
     class MappingRule
+      include DeepDupable
+
       attr_reader :name,
                   :to,
                   :to_instance,
@@ -163,7 +165,7 @@ module Lutaml
         # This handles the case where collection is mutated with << or custom methods
         elsif mutated_collection?(value, instance)
           true
-        elsif instance.respond_to?(:using_default?) && instance.using_default?(to)
+        elsif instance.is_a?(Lutaml::Model::Serialize) && instance.using_default?(to)
           render_default? || RenderPolicy.derived_attribute_for?(instance, to)
         else
           true
@@ -200,13 +202,13 @@ module Lutaml
         return false if value.empty? # Empty collection is still default
 
         # If it's a non-empty collection and marked as using_default, it was mutated
-        instance.respond_to?(:using_default?) && instance.using_default?(to)
+        instance.is_a?(Lutaml::Model::Serialize) && instance.using_default?(to)
       end
 
       # Check if value is a non-empty collection
       def has_items?(value)
         return false if value.nil? || Utils.uninitialized?(value)
-        return false unless value.respond_to?(:empty?)
+        return false unless value.is_a?(String) || value.is_a?(Array) || value.is_a?(Hash)
 
         !value.empty?
       end

data/lib/lutaml/model/sequence.rb

@@ -3,6 +3,8 @@
 module Lutaml
   module Model
     class Sequence
+      include DeepDupable
+
       attr_accessor :model, :attributes
       attr_reader :format
 
@@ -82,11 +84,11 @@ module Lutaml
       def validate_child_content(instance, register)
         instance.class.attributes(register).each_key do |name|
           value = instance.public_send(name)
-          if value.respond_to?(:validate!)
+          if value.is_a?(Lutaml::Model::Serialize)
             value.validate!
           elsif value.is_a?(Array)
             value.each do |v|
-              v.validate!(register: register) if v.respond_to?(:validate!)
+              v.validate!(register: register) if v.is_a?(Lutaml::Model::Serialize)
             end
           end
         end

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

@@ -180,9 +180,14 @@ module Lutaml
           # (Single Source of Truth - no longer uses instance variables)
           TransformationRegistry.instance.clear
 
+          # Clear Transform cache (uses class identity as key)
+          Transform.invalidate_for(self, register_id)
+
           # Clear import resolution guard flags so imports can be re-resolved
           instance_variables.each do |ivar|
-            remove_instance_variable(ivar) if ivar.to_s.start_with?("@_imports_resolved_")
+            ivar_s = ivar.to_s
+            remove_instance_variable(ivar) if ivar_s.start_with?("@_imports_resolved_") ||
+              ivar_s == "@_register_methods_defined"
           end
         end
 
@@ -282,14 +287,96 @@ module Lutaml
         def allocate_for_deserialization(register = nil)
           instance = allocate
           register_id = extract_register_id(register)
-          instance.init_deserialization_state(register_id)
-          instance.send(:define_singleton_attribute_methods)
-          instance.send(:register_in_reference_store)
+          instance.finalize_deserialization(register_id)
           instance
         end
 
+        # Define register-specific attribute methods on the class itself.
+        #
+        # Called once per (class, register) combination. Replaces per-instance
+        # singleton class allocation with class-level method definitions,
+        # preserving Ruby's inline method cache optimization.
+        #
+        # @param register_id [Symbol] The register ID
+        def ensure_register_methods_defined(register_id)
+          return if register_id == :default
+
+          @_register_methods_defined ||= {}
+          return if @_register_methods_defined[register_id]
+
+          reg_record = register_records[register_id]
+          return unless reg_record
+
+          default_attrs = instance_variable_get(:@attributes) || {}
+          reg_record_attrs = reg_record[:attributes] || {}
+
+          reg_record_attrs.each do |name, attr|
+            next if default_attrs.key?(name)
+            next if method_defined?(name, false)
+
+            if attr.collection?
+              define_collection_register_methods(name)
+            else
+              define_scalar_register_methods(name)
+            end
+          end
+
+          @_register_methods_defined[register_id] = true
+        end
+
         private
 
+        # Define getter/setter for a scalar register-specific attribute.
+        def define_scalar_register_methods(name)
+          define_method(name) do |*args|
+            if args.empty?
+              instance_variable_get(:"@#{name}")
+            else
+              send(:"#{name}=", args.first)
+              track_order(name, args.first, nil) if @__order_tracking__
+              args.first
+            end
+          end
+
+          define_method(:"#{name}=") do |value|
+            value_set_for(name)
+            reg_attr = resolve_register_attr(name)
+            value = reg_attr.cast_value(value, lutaml_register)
+            instance_variable_set(:"@#{name}", value)
+          end
+        end
+
+        # Define getter/setter for a collection register-specific attribute.
+        def define_collection_register_methods(name)
+          define_method(name) do |*args|
+            if args.empty?
+              current = instance_variable_get(:"@#{name}")
+              current.equal?(LAZY_EMPTY_COLLECTION) ? [] : current
+            else
+              value = args.first
+              current = instance_variable_get(:"@#{name}")
+              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__
+              value
+            end
+          end
+
+          define_method(:"#{name}=") do |value|
+            value_set_for(name)
+            reg_attr = resolve_register_attr(name)
+            value = reg_attr.cast_value(value, lutaml_register)
+            current = instance_variable_get(:"@#{name}")
+            if current.equal?(LAZY_EMPTY_COLLECTION) &&
+                (value.nil? || Lutaml::Model::Utils.uninitialized?(value))
+              # Sentinel stays — no allocation for empty collections
+            else
+              instance_variable_set(:"@#{name}", value)
+            end
+          end
+        end
+
         # Extract and normalize register ID with default fallback
         #
         # Resolution order:

data/lib/lutaml/model/serialize.rb

@@ -116,6 +116,15 @@ module Lutaml
         end
       end
 
+      # Complete deserialization initialization after allocation.
+      # Called by allocate_for_deserialization to set up instance state,
+      # define register-specific methods, and register in the reference store.
+      def finalize_deserialization(register)
+        init_deserialization_state(register)
+        define_singleton_attribute_methods
+        register_in_reference_store
+      end
+
       def extract_register_id(attrs, options)
         register = attrs&.dig(:lutaml_register) || options&.dig(:register)
         self.class.extract_register_id(register)
@@ -242,40 +251,25 @@ module Lutaml
         # No-op by default
       end
 
-      private
-
-      # Define attribute accessor methods on the instance's singleton class
-      # for attributes that are register-specific (not defined at class level).
+      # Ensure register-specific attribute methods are defined on the class.
+      # Delegates to the class method which defines methods once per
+      # (class, register) combination instead of per-instance singleton methods.
       def define_singleton_attribute_methods
-        return if lutaml_register == :default
-
-        # Access class-level register_records via self.class to avoid
-        # triggering ensure_imports! which would resolve types in wrong context
-        reg_records = self.class.register_records
-        return unless reg_records
-
-        reg_record = reg_records[lutaml_register]
-        return unless reg_record
-
-        reg_record_attrs = reg_record[:attributes] || {}
-        # @attributes contains default register's class-level attributes
-        default_attrs = self.class.instance_variable_get(:@attributes) || {}
+        self.class.ensure_register_methods_defined(lutaml_register)
+      end
 
-        reg_record_attrs.each do |name, attr|
-          # Skip if already defined at class level (from default register)
-          next if default_attrs.key?(name)
+      def register_in_reference_store
+        Lutaml::Model::Store.register(self)
+      end
 
-          # Define getter on singleton class
-          singleton_class.define_method(name) do
-            instance_variable_get(:"@#{name}")
-          end
+      private
 
-          # Define setter on singleton class with type casting
-          singleton_class.define_method(:"#{name}=") do |value|
-            value = attr.cast_value(value, lutaml_register)
-            instance_variable_set(:"@#{name}", value)
-          end
-        end
+      # Resolve the Attribute object for a register-specific attribute.
+      # Used by class-level setter methods to get the correct Attribute
+      # for the instance's active register.
+      def resolve_register_attr(name)
+        self.class.register_records[lutaml_register]&.dig(:attributes, name) ||
+          self.class.attributes[name]
       end
 
       def initialize_attributes(attrs, options = {})
@@ -308,10 +302,6 @@ module Lutaml
         end
       end
 
-      def register_in_reference_store
-        Lutaml::Model::Store.register(self)
-      end
-
       def resolve_reference_key(ref)
         return nil if ref.nil?
 

data/lib/lutaml/model/store.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require "weakref"
+
 module Lutaml
   module Model
     class Store
+      # Compact dead WeakRef shells after this many entries per class bucket.
+      COMPACTION_THRESHOLD = 1000
+
       class << self
         def instance
           @instance ||= new
@@ -31,28 +36,92 @@ module Lutaml
 
       def initialize
         @store = ::Hash.new { |hash, key| hash[key] = [] }
+        # Lazy index: built on first resolve for a given (class, key) pair.
+        # Key: [class_name, reference_method] → { value => WeakRef(object) }
+        @index = {}
       end
 
       def register(object)
-        model_class = object.class.to_s
+        model_key = object.class.to_s
+        refs = @store[model_key]
+        refs << WeakRef.new(object)
+
+        compact_if_needed(refs)
 
-        @store[model_class] << object
+        update_existing_indices(object, model_key)
       end
 
       def resolve(model_class, reference_key, reference_value)
-        return nil unless @store[model_class.to_s]
+        model_key = model_class.to_s
+        index_key = [model_key, reference_key]
+
+        # Build index lazily on first resolve for this (class, key) pair
+        unless @index.key?(index_key)
+          ensure_index(index_key, model_key,
+                       reference_key)
+        end
 
-        @store[model_class.to_s].find do |obj|
-          obj.send(reference_key) == reference_value
+        # O(1) indexed lookup
+        entry = @index[index_key][reference_value]
+        return nil unless entry
+
+        begin
+          entry.__getobj__ if entry.weakref_alive?
+        rescue WeakRef::RefError
+          nil
         end
       end
 
       def clear
         @store = ::Hash.new { |hash, key| hash[key] = [] }
+        @index = {}
       end
 
       def store
-        @store
+        @store.transform_values do |refs|
+          refs.each_with_object([]) do |ref, alive|
+            alive << ref.__getobj__ if ref.weakref_alive?
+          rescue WeakRef::RefError
+            nil
+          end
+        end
+      end
+
+      private
+
+      # Build index for a (model_class, reference_key) pair by scanning existing instances.
+      def ensure_index(index_key, model_key, reference_key)
+        entries = @index[index_key] = {}
+        @store[model_key]&.each do |ref|
+          obj = ref.__getobj__
+          value = obj.public_send(reference_key)
+          entries[value] = WeakRef.new(obj) if value
+        rescue WeakRef::RefError
+          next
+        end
+      end
+
+      # Update indices that already exist for this model class.
+      def update_existing_indices(object, model_key)
+        @index.each do |index_key, entries|
+          next unless index_key[0] == model_key
+
+          key_method = index_key[1]
+          value = object.public_send(key_method)
+          entries[value] = WeakRef.new(object) if value
+        rescue WeakRef::RefError
+          next
+        end
+      end
+
+      def compact_if_needed(refs)
+        return unless refs.size > COMPACTION_THRESHOLD
+
+        refs.reject! do |ref|
+          !ref.weakref_alive?
+        rescue WeakRef::RefError
+          true
+        end
       end
     end
   end

data/lib/lutaml/model/transform.rb

@@ -6,7 +6,8 @@ module Lutaml
       @transform_cache = {}
 
       # Maximum number of cached Transform instances before eviction.
-      MAX_CACHE_SIZE = 256
+      # Covers most OOXML/ISO schemas with ~1000+ classes and multiple registers.
+      MAX_CACHE_SIZE = 2048
 
       def self.data_to_model(context, data, format, options = {})
         register = options[:register] || Lutaml::Model::Config.default_register
@@ -15,7 +16,7 @@ module Lutaml
       end
 
       def self.model_to_data(context, model, format, options = {})
-        register = model.lutaml_register if model.respond_to?(:lutaml_register)
+        register = model.lutaml_register if model.is_a?(Lutaml::Model::Serialize)
         register ||= Lutaml::Model::Config.default_register
         transform = cached_transform(context, register)
         transform.model_to_data(model, format, options)
@@ -23,7 +24,7 @@ module Lutaml
 
       def self.cached_transform(context, register)
         @transform_cache ||= {}
-        cache_key = [context.object_id, register]
+        cache_key = [context, register]
         entry = @transform_cache[cache_key]
         return entry if entry
 
@@ -39,6 +40,16 @@ module Lutaml
         @transform_cache&.size || 0
       end
 
+      def self.invalidate_for(context, register = nil)
+        return unless @transform_cache
+
+        if register
+          @transform_cache.delete([context, register])
+        else
+          @transform_cache.reject! { |(ctx, _reg)| ctx == context }
+        end
+      end
+
       def self.evict_if_needed
         # Evict oldest half of entries when cache is full
         keys_to_remove = @transform_cache.keys.first(@transform_cache.size / 2)

data/lib/lutaml/model/type/hash.rb

@@ -8,10 +8,10 @@ module Lutaml
           return super if Utils.uninitialized?(value)
           return nil if value.nil?
 
-          hash = if value.respond_to?(:to_h)
-                   value.to_h
-                 else
-                   Hash(value)
+          hash = case value
+                 when ::Hash then value
+                 when ::Array then value.to_h
+                 else value.to_h
                  end
 
           normalize_hash(hash)
@@ -40,7 +40,11 @@ module Lutaml
           return nil if value.nil?
           return value if value.is_a?(::Hash)
 
-          value.respond_to?(:to_h) ? value.to_h : Hash(value)
+          case value
+          when ::Hash then value
+          when ::Array then value.to_h
+          else value.to_h
+          end
         end
 
         # XSD type for Hash

data/lib/lutaml/model/type/symbol.rb

@@ -7,7 +7,7 @@ module Lutaml
         def self.cast(value, options = {})
           return nil if value.nil?
           return value if Utils.uninitialized?(value)
-          return nil if value.respond_to?(:empty?) && value.empty?
+          return nil if value.is_a?(::String) && value.empty?
 
           # Convert to string for validation and unwrapping
           str_value = if value.is_a?(::Symbol)

data/lib/lutaml/model/utils.rb

@@ -115,18 +115,25 @@ module Lutaml
         end
 
         def blank?(value)
-          value.respond_to?(:empty?) ? value.empty? : value.nil?
+          case value
+          when ::String, ::Array, ::Hash then value.empty?
+          when ::NilClass then true
+          else false
+          end
         end
 
         def empty_collection?(collection)
           return false if collection.nil?
-          return false unless [Array, Hash].include?(collection.class)
+          return false unless [::Array, ::Hash].include?(collection.class)
 
           collection.empty?
         end
 
         def empty?(value)
-          value.respond_to?(:empty?) ? value.empty? : false
+          case value
+          when ::String, ::Array, ::Hash then value.empty?
+          else false
+          end
         end
 
         def add_if_present(hash, key, value)
@@ -273,7 +280,11 @@ module Lutaml
         end
 
         def deep_dup_object(object)
-          object.respond_to?(:deep_dup) ? object.deep_dup : object.dup
+          if object.is_a?(DeepDupable)
+            object.deep_dup
+          else
+            object.dup
+          end
         end
 
         def camelize_part(part)

data/lib/lutaml/model/validation.rb

@@ -10,7 +10,7 @@ module Lutaml
           value = public_send(:"#{name}")
 
           begin
-            if value.respond_to?(:validate)
+            if value.is_a?(Lutaml::Model::Serialize)
               sub_errors = value.validate
               errors.concat(sub_errors) if sub_errors.is_a?(Array)
             else
@@ -74,8 +74,14 @@ module Lutaml
         nil
       end
 
+      # Default: no element order. XML overrides via InstanceMethods prepend
+      # with attr_accessor :element_order.
+      def element_order
+        nil
+      end
+
       def order_names
-        return [] unless respond_to?(:element_order) && element_order
+        return [] unless element_order
 
         element_order.each_with_object([]) do |element, arr|
           next if element.text?

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.7"
+    VERSION = "0.8.8"
   end
 end

data/lib/lutaml/model.rb

@@ -33,6 +33,7 @@ module Lutaml
     autoload :AdapterResolver, "#{__dir__}/model/adapter_resolver"
     autoload :AdapterScope, "#{__dir__}/model/adapter_scope"
     autoload :Utils, "#{__dir__}/model/utils"
+    autoload :DeepDupable, "#{__dir__}/model/deep_dupable"
     autoload :Serializable, "#{__dir__}/model/serializable"
     autoload :Error, "#{__dir__}/model/error"
     autoload :Constants, "#{__dir__}/model/constants"

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

@@ -34,6 +34,8 @@ module Lutaml
         def clear_xml_parse_state!
           @import_declaration_plan = nil
           @pending_plan_root_element = nil
+          @element_order = nil
+          @attribute_order = nil
           self
         end
 

data/lib/lutaml/xml/xml_element.rb

@@ -282,7 +282,7 @@ module Lutaml
                                      namespace_uri: child.namespace_uri,
                                      namespace_prefix: child.namespace_prefix)
           end
-        end
+        end.each(&:freeze).freeze
       end
 
       def root

data/spec/lutaml/model/attribute_spec.rb

@@ -288,30 +288,19 @@ RSpec.describe Lutaml::Model::Attribute do
   describe "#deep_dup" do
     let(:duplicate_attribute) { Lutaml::Model::Utils.deep_dup(attribute) }
 
-    context "when deep_dup method is not defined and instance is deep_duplicated" do
-      let(:attribute) { described_class.new("name", :string) }
-
-      before do
-        described_class.alias_method :orig_deep_dup, :deep_dup
-        described_class.undef_method :deep_dup
-      end
-
-      after do
-        described_class.alias_method :deep_dup, :orig_deep_dup
-        attribute.options.delete(:foo)
-      end
-
-      it "confirms that options values are linked of original and duplicate instances" do
-        duplicate_attribute
-        attribute.options[:foo] = "bar"
-        expect(duplicate_attribute.options).to include(:foo)
+    context "when object does not include DeepDupable" do
+      it "falls back to dup for plain objects" do
+        plain = Struct.new(:value).new("hello")
+        result = Lutaml::Model::Utils.deep_dup(plain)
+        expect(result.value).to eq("hello")
+        expect(result).not_to equal(plain)
       end
     end
 
-    context "when deep_dup method is defined and instance is deep_duplicated" do
+    context "when Attribute is deep_duplicated" do
       let(:attribute) { described_class.new("name", :string) }
 
-      it "confirms that options values are not linked of original and duplicate instances" do
+      it "creates independent copies of options" do
         duplicate_attribute
         attribute.options[:foo] = "bar"
         expect(duplicate_attribute.options).not_to include(:foo)

data/spec/lutaml/model/register_methods_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Register-specific attribute methods" do
+  let(:register) do
+    Lutaml::Model::Register.new(:register_methods_test,
+                                fallback: [:default])
+  end
+
+  let(:base_model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      xml do
+        root "Base"
+        map_element "Name", to: :name
+      end
+    end
+  end
+
+  let(:extension_model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :version, :string
+      attribute :priority, :integer
+
+      xml do
+        root "Extension"
+        map_element "Version", to: :version
+        map_element "Priority", to: :priority
+      end
+    end
+  end
+
+  before do
+    Lutaml::Model::GlobalContext.reset!
+    Lutaml::Model::GlobalRegister.register(register)
+    register.register_model(extension_model, id: :extension_model)
+    base_model.import_model_attributes(extension_model, register.id)
+  end
+
+  describe "class-level method definition" do
+    it "does not create singleton class methods for register-specific attributes" do
+      instance = base_model.new({ name: "test",
+                                  version: "1.0" },
+                                register: register.id)
+
+      expect(instance.version).to eq("1.0")
+
+      # Method should be on the class, NOT directly on the singleton class
+      expect(instance.singleton_class.instance_methods(false)).not_to include(:version)
+      expect(instance.singleton_class.instance_methods(false)).not_to include(:version=)
+    end
+
+    it "defines methods on the class accessible to all instances" do
+      instance1 = base_model.new({ name: "a" }, register: register.id)
+      instance2 = base_model.new({ name: "b" }, register: register.id)
+
+      instance1.version = "1.0"
+      instance2.version = "2.0"
+
+      expect(instance1.version).to eq("1.0")
+      expect(instance2.version).to eq("2.0")
+    end
+
+    it "guards against re-definition with @_register_methods_defined" do
+      base_model.new({ name: "a" }, register: register.id)
+
+      guard = base_model.instance_variable_get(:@_register_methods_defined)
+      expect(guard).to include(register.id => true)
+
+      # Second instance creation should not re-trigger method definition
+      base_model.new({ name: "b" }, register: register.id)
+      expect(guard[register.id]).to be(true)
+    end
+  end
+
+  describe "type casting in setter" do
+    it "casts integer values correctly" do
+      instance = base_model.new({ name: "test" }, register: register.id)
+
+      instance.priority = "5"
+      expect(instance.priority).to eq(5)
+    end
+
+    it "casts string values correctly" do
+      instance = base_model.new({ name: "test" }, register: register.id)
+
+      instance.version = 42
+      expect(instance.version).to eq("42")
+    end
+  end
+
+  describe "value_set_for tracking" do
+    it "marks register-specific attributes as explicitly set" do
+      instance = base_model.new({ name: "test" }, register: register.id)
+
+      # After initialization, version was set via public_send in initialize_attributes
+      expect(instance.using_default?(:version)).to be(false)
+    end
+
+    it "uses default when register-specific attribute is not provided" do
+      instance = base_model.allocate_for_deserialization(register.id)
+
+      # Not yet set — using default
+      expect(instance.using_default?(:version)).to be(true)
+
+      instance.version = "1.0"
+      expect(instance.using_default?(:version)).to be(false)
+    end
+  end
+
+  describe "default register instances" do
+    it "returns early without defining methods for :default register" do
+      base_model.ensure_register_methods_defined(:default)
+
+      guard = base_model.instance_variable_get(:@_register_methods_defined)
+      expect(guard).to be_nil
+    end
+
+    it "default-register instances still work for class-level attributes" do
+      instance = base_model.new(name: "test")
+
+      expect(instance.name).to eq("test")
+      instance.name = "changed"
+      expect(instance.name).to eq("changed")
+    end
+  end
+
+  describe "deserialization path" do
+    it "defines methods via finalize_deserialization" do
+      instance = base_model.allocate_for_deserialization(register.id)
+      instance.version = "3.0"
+
+      expect(instance.version).to eq("3.0")
+      expect(instance.singleton_class.instance_methods(false)).not_to include(:version)
+    end
+  end
+
+  describe "clear_cache resets the guard" do
+    it "clears @_register_methods_defined on clear_cache" do
+      base_model.new({ name: "a" }, register: register.id)
+      expect(base_model.instance_variable_get(:@_register_methods_defined)).not_to be_nil
+
+      base_model.clear_cache
+      expect(base_model.instance_variable_get(:@_register_methods_defined)).to be_nil
+    end
+  end
+end

data/spec/lutaml/model/store_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Store do
+  let(:model_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :id, :string
+      attribute :name, :string
+    end
+  end
+
+  before { described_class.clear }
+  after { described_class.clear }
+
+  describe "#register and #resolve" do
+    it "resolves a registered object by reference key" do
+      obj = model_class.new(id: "abc", name: "test")
+      result = described_class.resolve(model_class, :id, "abc")
+      expect(result).to eq(obj)
+    end
+
+    it "returns nil for non-existent reference" do
+      model_class.new(id: "abc")
+      result = described_class.resolve(model_class, :id, "nonexistent")
+      expect(result).to be_nil
+    end
+
+    it "returns nil for non-existent class" do
+      other_class = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+      end
+      result = described_class.resolve(other_class, :id, "anything")
+      expect(result).to be_nil
+    end
+
+    it "resolves by name attribute" do
+      obj = model_class.new(id: "abc", name: "myobj")
+      result = described_class.resolve(model_class, :name, "myobj")
+      expect(result).to eq(obj)
+    end
+  end
+
+  describe "indexed lookup" do
+    it "builds index lazily on first resolve" do
+      5.times { |i| model_class.new(id: "obj-#{i}") }
+
+      result = described_class.resolve(model_class, :id, "obj-3")
+      expect(result.id).to eq("obj-3")
+    end
+
+    it "updates index when new objects are registered after first resolve" do
+      model_class.new(id: "first")
+      described_class.resolve(model_class, :id, "first") # triggers index build
+
+      model_class.new(id: "second")
+      result = described_class.resolve(model_class, :id, "second")
+      expect(result.id).to eq("second")
+    end
+
+    it "reuses index across multiple resolves for same key" do
+      10.times { |i| model_class.new(id: "obj-#{i}") }
+
+      # First resolve builds the index
+      described_class.resolve(model_class, :id, "obj-5")
+      # Second resolve should use the same index
+      result = described_class.resolve(model_class, :id, "obj-7")
+      expect(result.id).to eq("obj-7")
+    end
+  end
+
+  describe "WeakRef behavior" do
+    it "uses WeakRef for storage (objects can be collected when unreferenced)" do
+      obj = model_class.new(id: "alive")
+      result = described_class.resolve(model_class, :id, "alive")
+      expect(result).to eq(obj)
+    end
+
+    it "resolves objects with strong references held externally" do
+      obj = model_class.new(id: "alive")
+      GC.start
+      result = described_class.resolve(model_class, :id, "alive")
+      expect(result).to eq(obj)
+    end
+  end
+
+  describe "#store" do
+    it "returns only live objects" do
+      obj1 = model_class.new(id: "keep")
+      _obj2 = model_class.new(id: "drop")
+      _obj2 = nil
+      GC.start
+
+      entries = described_class.store[model_class.to_s]
+      # obj1 should be alive; obj2 may or may not be GC'd depending on timing
+      expect(entries).to include(obj1)
+    end
+  end
+
+  describe "#clear" do
+    it "removes all registered objects" do
+      model_class.new(id: "a")
+      model_class.new(id: "b")
+      described_class.clear
+
+      expect(described_class.resolve(model_class, :id, "a")).to be_nil
+      expect(described_class.resolve(model_class, :id, "b")).to be_nil
+    end
+
+    it "clears the index" do
+      model_class.new(id: "indexed")
+      described_class.resolve(model_class, :id, "indexed") # build index
+      described_class.clear
+
+      model_class.new(id: "new-one")
+      result = described_class.resolve(model_class, :id, "new-one")
+      expect(result.id).to eq("new-one")
+    end
+  end
+end

data/spec/lutaml/model/transform_cache_spec.rb

@@ -59,4 +59,46 @@ RSpec.describe "Transform caching" do
       expect(Lutaml::Model::Transform.cache_size).to be <= 4
     end
   end
+
+  describe ".invalidate_for" do
+    it "invalidates cache for a specific context" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      t1 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      Lutaml::Model::Transform.invalidate_for(klass)
+      t2 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      expect(t1).not_to equal(t2)
+    end
+
+    it "invalidates cache for a specific context and register" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      t1_default = Lutaml::Model::Transform.cached_transform(klass, :default)
+      t1_other = Lutaml::Model::Transform.cached_transform(klass, :other)
+
+      Lutaml::Model::Transform.invalidate_for(klass, :default)
+
+      t2_default = Lutaml::Model::Transform.cached_transform(klass, :default)
+      t2_other = Lutaml::Model::Transform.cached_transform(klass, :other)
+
+      expect(t1_default).not_to equal(t2_default)
+      expect(t1_other).to equal(t2_other)
+    end
+
+    it "uses class identity as key, not object_id" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      t1 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      # Force GC — object_id reuse should not cause stale hits
+      GC.start
+      t2 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      expect(t1).to equal(t2)
+    end
+  end
 end

data/spec/lutaml/xml/clear_parse_state_spec.rb

@@ -75,11 +75,18 @@ RSpec.describe "#clear_xml_parse_state!" do
   end
 
   describe "user-facing attributes" do
-    it "does not clear element_order" do
+    it "clears element_order to release parse buffers" do
       model = model_class.from_xml(xml_with_ns)
-      original_order = model.element_order
+      expect(model.element_order).not_to be_nil
       model.clear_xml_parse_state!
-      expect(model.element_order).to eq(original_order)
+      expect(model.element_order).to be_nil
+    end
+
+    it "clears attribute_order to release parse buffers" do
+      model = model_class.from_xml(xml_with_ns)
+      expect(model.attribute_order).not_to be_nil
+      model.clear_xml_parse_state!
+      expect(model.attribute_order).to be_nil
     end
 
     it "does not clear encoding" do

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

@@ -32,6 +32,21 @@ RSpec.describe "Schema mapping integration" do
       expect(parsed.target_namespace_prefix).to eq("t")
       expect(parsed.element.first.target_prefix).to eq("t")
     end
+
+    it "captures nil prefix when target namespace is the default (unprefixed)" do
+      xsd_default_ns = <<~XSD
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                   xmlns="http://example.com/default"
+                   targetNamespace="http://example.com/default">
+          <xs:element name="Root" type="xs:string"/>
+        </xs:schema>
+      XSD
+
+      parsed = Lutaml::Xml::Schema::Xsd.parse(xsd_default_ns)
+
+      expect(parsed.target_namespace).to eq("http://example.com/default")
+      expect(parsed.target_namespace_prefix).to be_nil
+    end
   end
 
   describe "parsing with exact string mappings" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.8.8
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -404,6 +404,7 @@ files:
 - lib/lutaml/model/consolidation_rule/pattern_element_rule.rb
 - lib/lutaml/model/constants.rb
 - lib/lutaml/model/context_registry.rb
+- lib/lutaml/model/deep_dupable.rb
 - lib/lutaml/model/error.rb
 - lib/lutaml/model/error/choice_lower_bound_error.rb
 - lib/lutaml/model/error/choice_upper_bound_error.rb
@@ -1617,6 +1618,7 @@ files:
 - spec/lutaml/model/polymorphic_spec.rb
 - spec/lutaml/model/processing_instruction_spec.rb
 - spec/lutaml/model/register_key_value_spec.rb
+- spec/lutaml/model/register_methods_spec.rb
 - spec/lutaml/model/register_spec.rb
 - spec/lutaml/model/render_empty_spec.rb
 - spec/lutaml/model/render_nil_spec.rb
@@ -1637,6 +1639,7 @@ files:
 - spec/lutaml/model/services/default_value_resolver_spec.rb
 - spec/lutaml/model/services/transformer_spec.rb
 - spec/lutaml/model/simple_model_spec.rb
+- spec/lutaml/model/store_spec.rb
 - spec/lutaml/model/toml_adapter_spec.rb
 - spec/lutaml/model/toml_spec.rb
 - spec/lutaml/model/transform_cache_spec.rb