lutaml-model 0.8.6 → 0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c356719b1c0c3434ba1acb3f59be81cb9374403c8020710ee4d4a5ea78748765
-  data.tar.gz: ac2aa51ef80ce8db3c50b8055df95b6a3732e3e40b72689c635e8ac22fe889f2
+  metadata.gz: 076bdbfb0836ad989e3fe90d5287d9662f35fb00492b6dfed0aef95db7296cdd
+  data.tar.gz: 1008556dd2eb02cd3aa08cffc2278f1952fab2d4c97af47a96eeea2b0975d622
 SHA512:
-  metadata.gz: b63ac862dc2eeef4a599ff5ada8c6f2434b3bf71187b5813a2637e69f25170692d373bffb2b9413b48323b1cd6161a8529a2ec6582a2fc313d46c95fa8b67088
-  data.tar.gz: 24e23bdedad47cc0796cff0bad1b32809c649bad4a13a64b23d08b3bef2dad4c769cfc299cdb85abeffd9a53ea677c41f91c759114f320a5047787cafc6c253e
+  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