lutaml-model 0.8.9 → 0.8.11

data/lib/lutaml/model/instrumentation.rb

@@ -167,7 +167,7 @@ module Lutaml
           return nil if Lutaml::Model::RuntimeCompatibility.opal?
           return nil unless defined?(GC)
 
-          GC.start if GC.respond_to?(:compact)
+          GC.start if RUBY_VERSION >= "2.7"
           IO.popen(["ps", "-o", "rss=", "-p", Process.pid.to_s],
                    &:read).to_i * 1024
         rescue StandardError

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

@@ -250,7 +250,7 @@ module Lutaml
 
       def serialize_attribute(model, element, doc)
         if custom_methods[:to]
-          model.send(custom_methods[:to], model, element, doc)
+          model.public_send(custom_methods[:to], model, element, doc)
         end
       end
 
@@ -266,7 +266,7 @@ module Lutaml
 
       def serialize(model, parent = nil, doc = nil)
         if custom_methods[:to]
-          model.send(custom_methods[:to], model, parent, doc)
+          model.public_send(custom_methods[:to], model, parent, doc)
         else
           value = to_value_for(model)
 
@@ -415,7 +415,7 @@ module Lutaml
       def handle_custom_method(model, value, mapper_class)
         return if !custom_methods[:from] || value.nil?
 
-        mapper_class.new.send(custom_methods[:from], model, value)
+        mapper_class.new.public_send(custom_methods[:from], model, value)
         true
       end
 

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

@@ -63,7 +63,7 @@ module Lutaml
           from_attr, to_attr = transform_attributes(rule, reverse: reverse)
           next if from_attr.nil? || to_attr.nil?
 
-          value = input.send(from_attr.name)
+          value = input.public_send(from_attr.name)
 
           value = transformed_value(value, rule, from_attr, to_attr,
                                     reverse: reverse)

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

@@ -47,7 +47,7 @@ module Lutaml
         when Proc
           transform.call(value)
         when String, Symbol
-          transformer.new.send(transform, value)
+          transformer.new.public_send(transform, value)
         when Class
           transform.public_send(transform_method, value, mapping: true)
         end

data/lib/lutaml/model/register.rb

@@ -95,7 +95,7 @@ module Lutaml
       end
 
       def self._resolve_for_child_uncached(child_class, parent_register)
-        default_reg = if child_class.respond_to?(:lutaml_default_register)
+        default_reg = if child_class.is_a?(Class) && child_class.include?(Lutaml::Model::Serialize)
                         child_class.lutaml_default_register
                       end
 
@@ -172,7 +172,7 @@ module Lutaml
 
         # Set @register on the class so instances know their context
         # This ensures proper OOP context propagation during serialization
-        klass.set_register_context(@id) if klass.respond_to?(:set_register_context)
+        klass.set_register_context(@id) if klass.is_a?(Class) && klass.include?(Lutaml::Model::Serialize)
 
         # Register in GlobalContext
         ctx = global_context
@@ -226,7 +226,7 @@ module Lutaml
         # Set register context using proper OOP method
         expected_class.set_register_context(id) if
           !(expected_class < Lutaml::Model::Type::Value) &&
-            expected_class.respond_to?(:set_register_context)
+            expected_class.is_a?(Class) && expected_class.include?(Lutaml::Model::Serialize)
 
         expected_class
       end

data/lib/lutaml/model/render_policy.rb

@@ -13,9 +13,11 @@ module Lutaml
     # time, so downstream code never needs to re-interpret them.
     module RenderPolicy
       def self.derived_attribute_for?(context_obj, attr_name)
-        return false unless context_obj&.class.respond_to?(:attributes)
+        return false unless context_obj.is_a?(Lutaml::Model::Serialize) &&
+          context_obj.class.is_a?(Class) &&
+          context_obj.class.include?(Lutaml::Model::Serialize)
 
-        register = context_obj.respond_to?(:lutaml_register) ? context_obj.lutaml_register : nil
+        register = context_obj.lutaml_register
         context_obj.class.attributes(register)&.[](attr_name)&.derived?
       end
 
@@ -92,7 +94,7 @@ module Lutaml
       def should_skip_default?(value, rule, context_obj, attr_name)
         # Skip if context object is using default and render_default is false
         # But for collections, check if they were mutated (non-empty)
-        if context_obj.respond_to?(:using_default?) &&
+        if context_obj.is_a?(Lutaml::Model::Serialize) &&
             context_obj.using_default?(attr_name) &&
             !extract_option(rule, :render_default)
           return false if derived_attribute?(context_obj, attr_name)
@@ -115,31 +117,23 @@ module Lutaml
       # @param option_name [Symbol] The option name
       # @return [Object, nil] The option value
       def extract_option(rule, option_name)
-        if rule.respond_to?(:option)
+        if rule.is_a?(CompiledRule)
           rule.option(option_name)
-        elsif rule.respond_to?(option_name)
-          rule.send(option_name)
+        elsif rule.is_a?(MappingRule)
+          rule.public_send(option_name)
         end
       end
 
-      # Extract attribute name from rule
-      #
-      # @param rule [CompiledRule, MappingRule] The rule
-      # @return [Symbol] The attribute name
       def extract_attribute_name(rule)
-        if rule.respond_to?(:attribute_name)
+        if rule.is_a?(CompiledRule)
           rule.attribute_name
-        elsif rule.respond_to?(:to)
+        else
           rule.to
         end
       end
 
-      # Check if rule defines a collection
-      #
-      # @param rule [CompiledRule, MappingRule] The rule
-      # @return [Boolean] true if collection
       def collection?(rule)
-        if rule.respond_to?(:collection?)
+        if rule.is_a?(CompiledRule) || rule.is_a?(MappingRule)
           rule.collection?
         else
           false

data/lib/lutaml/model/runtime_compatibility.rb

@@ -11,7 +11,6 @@ module Lutaml
 
       def self.windows?
         defined?(Gem) &&
-          Gem.respond_to?(:win_platform?) &&
           Gem.win_platform?
       end
 

data/lib/lutaml/model/schema/xml_compiler/group.rb

@@ -101,7 +101,7 @@ module Lutaml
             # because sequence requires a root element
             if instance.is_a?(Sequence)
               # Output sequence content directly without the wrapper
-              instance.send(:xml_block_content, extended_indent)
+              instance.xml_block_content(extended_indent)
             else
               instance.to_xml_mapping(extended_indent)
             end

data/lib/lutaml/model/schema/xml_compiler/registry_generator.rb

@@ -106,7 +106,7 @@ module Lutaml
             "\n#{indent}# Resolve serialization mapping imports (sequence imports)\n" +
               @classes.keys.filter_map do |name|
                 next if name.to_s.include?("Namespace")
-                next unless @classes[name].respond_to?(:mappings)
+                next unless @classes[name].is_a?(Class) && @classes[name].include?(Lutaml::Model::Serialize)
 
                 class_name = Utils.camel_case(name)
                 "#{indent}#{class_name}.mappings[:xml].ensure_mappings_imported!(:#{@register_id}) if #{class_name}.mappings[:xml]&.respond_to?(:ensure_mappings_imported!)"

data/lib/lutaml/model/schema/xml_compiler/sequence.rb

@@ -40,8 +40,6 @@ module Lutaml
             @instances.map(&:required_files)
           end
 
-          private
-
           def xml_block_content(indent)
             instances.filter_map do |instance|
               instance.to_xml_mapping(indent * 2)

data/lib/lutaml/model/schema/xml_compiler.rb

@@ -166,7 +166,7 @@ module Lutaml
             require "#{dir}/registry"
 
             # Call register_all to register all classes
-            GeneratedModels.register_all if GeneratedModels.respond_to?(:register_all)
+            GeneratedModels.register_all if defined?(GeneratedModels)
           end
         end
 
@@ -210,7 +210,12 @@ module Lutaml
             schema_to_models(schema.import) if schema.import&.any?
             # Use schema's resolved_element_order which returns properly typed XSD objects
             schema.resolved_element_order.each do |order_item|
-              item_name = order_item.name if order_item.respond_to?(:name)
+              item_name = order_item.name if order_item.is_a?(Lutaml::Xml::Schema::Xsd::SimpleType) ||
+                order_item.is_a?(Lutaml::Xml::Schema::Xsd::Group) ||
+                order_item.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType) ||
+                order_item.is_a?(Lutaml::Xml::Schema::Xsd::Element) ||
+                order_item.is_a?(Lutaml::Xml::Schema::Xsd::Attribute) ||
+                order_item.is_a?(Lutaml::Xml::Schema::Xsd::AttributeGroup)
               case order_item
               when Lutaml::Xml::Schema::Xsd::SimpleType
                 @simple_types[item_name] = setup_simple_type(order_item)
@@ -246,8 +251,6 @@ module Lutaml
         end
 
         def restriction_content(instance, restriction)
-          return instance unless restriction.respond_to?(:max_length)
-
           restriction_min_max(restriction, instance, field: :max_length,
                                                      value_method: :min)
           restriction_min_max(restriction, instance, field: :min_length,
@@ -271,7 +274,7 @@ module Lutaml
 
           instance.public_send(
             :"#{field}=",
-            field_value.map(&:value).send(value_method).to_s,
+            field_value.map(&:value).public_send(value_method).to_s,
           )
         end
 
@@ -447,12 +450,10 @@ module Lutaml
         def setup_restriction(restriction)
           Restriction.new.tap do |instance|
             instance.base_class = restriction.base
-            if restriction.respond_to?(:pattern)
-              restriction_patterns(restriction.pattern,
-                                   instance)
-            end
+            restriction_patterns(restriction.pattern,
+                                 instance)
             restriction_content(instance, restriction)
-            if restriction.respond_to?(:enumeration) && restriction.enumeration&.any?
+            if restriction.enumeration&.any?
               instance.enumerations = restriction.enumeration.map(&:value)
             end
           end
@@ -523,10 +524,9 @@ compiler_complex_type)
         def resolved_element_order(object)
           return [] if object.element_order.nil?
 
-          # If the object has its own resolved_element_order method (like XSD objects),
+          # If the object is an XSD type (which has its own resolved_element_order),
           # use it instead of processing element_order which returns generic XML elements
-          if object.respond_to?(:resolved_element_order) &&
-              object.class.name.start_with?("Lutaml::Xml::Schema::Xsd", "Lutaml::Xml::Schema::Xsd")
+          if object.is_a?(Lutaml::Xml::Schema::Xsd::Base)
             return object.resolved_element_order
           end
 
@@ -538,7 +538,7 @@ compiler_complex_type)
               next unless element == builder_instance
 
               array[i] =
-                Array(object.send(Utils.snake_case(builder_instance.name)))[index]
+                Array(object.public_send(Utils.snake_case(builder_instance.name)))[index]
               index += 1
             end
           end

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

@@ -122,7 +122,7 @@ module Lutaml
               else
                 # Builder-style: g.description(value) sets the value
                 value = args.first
-                send(:"#{name}=", value)
+                public_send(:"#{name}=", value)
                 # Track order for mixed_content serialization
                 track_order(name, value, nil) if @__order_tracking__
                 value

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Serialize
+      # Encapsulates the parent-to-child options propagation contract.
+      #
+      # During deserialization, a parent passes context to its children via an
+      # options Hash. Only certain keys are safe to propagate — parent-internal
+      # keys (resolved_type, namespace_uri, converted) must be stripped so
+      # children derive their own context.
+      #
+      # This class is the single source of truth for which keys propagate,
+      # replacing scattered CHILD_PROPAGATION_KEYS constants and ad-hoc
+      # `.slice` calls.
+      #
+      # Usage:
+      #   child_options = DeserializationContext.propagate(options).merge(register: register)
+      #   klass.apply_mappings(value, format, child_options)
+      class DeserializationContext
+        # Keys that are safe to propagate from parent to child deserialization.
+        #
+        # Parent-internal keys (namespace_uri, resolved_type, converted, mappings)
+        # are intentionally excluded — children must derive their own context.
+        PROPAGATION_KEYS = %i[
+          lutaml_parent
+          lutaml_root
+          default_namespace
+          import_declaration_plan
+          polymorphic
+          collection
+          render_empty
+          render_nil
+          cdata
+        ].freeze
+
+        # Extract propagable keys from a parent options hash.
+        #
+        # Returns a new Hash containing only the keys safe for child
+        # deserialization. Parent-internal keys are excluded.
+        #
+        # @param options [Hash] The parent's options hash
+        # @return [Hash] A new hash with only propagable keys
+        def self.propagate(options)
+          options.slice(*PROPAGATION_KEYS)
+        end
+      end
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ module Lutaml
                              end
           mappings[format].instance_eval(&)
 
-          if mappings[format].respond_to?(:finalize)
+          if mappings[format].is_a?(Lutaml::Xml::Mapping)
             mappings[format].finalize(self)
           end
 
@@ -172,7 +172,7 @@ module Lutaml
 
           if format == :yamls
             mapping = mappings[format]
-            return true if mapping.respond_to?(:yamls_sequence) && mapping.yamls_sequence
+            return true if mapping.is_a?(Lutaml::Yamls::Adapter::Mapping) && mapping.yamls_sequence
           end
 
           false

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

@@ -90,15 +90,15 @@ module Lutaml
         #
         # @param source_class [Class] The source class to copy from
         def initialize_attrs(source_class)
-          @mappings = Utils.deep_dup(source_class.instance_variable_get(:@mappings)) || {}
-          @attributes = Utils.deep_dup(source_class.instance_variable_get(:@attributes)) || {}
+          @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.instance_variable_get(:@register_records),
+            source_class.register_records,
           ) || ::Hash.new do |hash, key|
                  hash[key] = { attributes: {}, choice_attributes: [] }
                end
-          instance_variable_set(:@model, self)
+          model(self)
         end
 
         # Deep duplicate choice attributes from a source class
@@ -106,7 +106,7 @@ module Lutaml
         # @param source_class [Class] The source class
         # @return [Array] The duplicated choice attributes
         def deep_duplicate_choice_attributes(source_class, register = nil)
-          choice_attrs = Array(source_class.instance_variable_get(:@choice_attributes))
+          choice_attrs = Array(source_class.choice_attributes)
           choice_attrs.map do |choice_attr|
             choice_attr.deep_duplicate(self, register)
           end
@@ -127,6 +127,13 @@ module Lutaml
           end
         end
 
+        # Raw class-level attributes without register merging.
+        # Used by initialize_attrs during class inheritance.
+        # @return [Hash] The raw attributes hash
+        def class_attributes
+          @attributes
+        end
+
         # Get all choice attributes for this model
         #
         # Merges class-level choice attributes with register-specific choice attributes.
@@ -176,6 +183,12 @@ module Lutaml
             GlobalContext.resolver.clear_cache(register_id)
           end
 
+          # Clear per-Attribute type caches (stale entries from GC'd TypeContext objects)
+          class_attributes.each_value(&:clear_type_cache)
+          @register_records&.each_value do |record|
+            record[:attributes]&.each_value(&:clear_type_cache)
+          end
+
           # Clear centralized mapping and transformation caches
           # (Single Source of Truth - no longer uses instance variables)
           TransformationRegistry.instance.clear
@@ -220,6 +233,12 @@ module Lutaml
             @using_default[attribute_name] = false
           end
 
+          Utils.add_method_if_not_defined(klass,
+                                          :values_set_for) do |attribute_names|
+            @using_default ||= {}
+            attribute_names.each { |name| @using_default[name] = false }
+          end
+
           Utils.add_method_if_not_defined(klass,
                                           :using_default?) do |attribute_name|
             @using_default ||= {}
@@ -246,6 +265,24 @@ module Lutaml
           value
         end
 
+        # Whether instances of this class should be registered in the
+        # global Store for reference resolution. Defaults to true for
+        # backward compatibility. Use `skip_reference_registration` to
+        # opt out for classes that never participate in cross-referencing.
+        def reference_resolvable?
+          return true unless instance_variable_defined?(:@skip_reference_registration)
+
+          !@skip_reference_registration
+        end
+
+        # Opt out of Store registration for this class.
+        # Instances will not be tracked in the global Store, saving
+        # memory and registration overhead for classes that are never
+        # resolved by reference (no xml_id or similar attributes).
+        def skip_reference_registration
+          @skip_reference_registration = true
+        end
+
         # Define a choice constraint
         #
         # @param min [Integer] Minimum number of choices
@@ -307,7 +344,7 @@ module Lutaml
           reg_record = register_records[register_id]
           return unless reg_record
 
-          default_attrs = instance_variable_get(:@attributes) || {}
+          default_attrs = class_attributes || {}
           reg_record_attrs = reg_record[:attributes] || {}
 
           reg_record_attrs.each do |name, attr|
@@ -332,7 +369,7 @@ module Lutaml
             if args.empty?
               instance_variable_get(:"@#{name}")
             else
-              send(:"#{name}=", args.first)
+              public_send(:"#{name}=", args.first)
               track_order(name, args.first, nil) if @__order_tracking__
               args.first
             end

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

@@ -79,7 +79,7 @@ module Lutaml
             klass = ::Lutaml::Model::Config.mappings_class_for(format)
             @mappings[format] ||= klass.new
             mapping = @mappings[format]
-            if mapping.respond_to?(:import_model_mappings)
+            if mapping.is_a?(Mapping)
               mapping.import_model_mappings(model,
                                             register_id)
             end

data/lib/lutaml/model/serialize.rb

@@ -6,6 +6,8 @@ module Lutaml
       # Autoload subdirectory modules
       autoload :Initialization, "#{__dir__}/serialize/initialization"
       autoload :AttributeDefinition, "#{__dir__}/serialize/attribute_definition"
+      autoload :DeserializationContext,
+               "#{__dir__}/serialize/deserialization_context"
       autoload :EnumHandling, "#{__dir__}/serialize/enum_handling"
       autoload :ModelImport, "#{__dir__}/serialize/model_import"
       autoload :FormatConversion, "#{__dir__}/serialize/format_conversion"
@@ -161,6 +163,11 @@ module Lutaml
         @using_default[attribute_name] = false
       end
 
+      def values_set_for(attribute_names)
+        @using_default ||= ::Hash.new(true)
+        attribute_names.each { |name| @using_default[name] = false }
+      end
+
       def using_default?(attribute_name)
         # nil means "all attributes using default" — return true without allocation
         return true if @using_default.nil?
@@ -259,7 +266,7 @@ module Lutaml
       end
 
       def register_in_reference_store
-        Lutaml::Model::Store.register(self)
+        Lutaml::Model::Store.register(self) if self.class.reference_resolvable?
       end
 
       private

data/lib/lutaml/model/services/rule_value_extractor.rb

@@ -36,7 +36,8 @@ instance_object)
         # When name is nil but document is a hash-like object with a single key matching
         # the attribute name, extract that value. This handles the case where
         # map to: :content is used and the document is {"content": "value"}
-        # Note: doc may be JSON::Ext::Generator::GeneratorMethods::Hash which is_a?(Hash) returns false
+        # Note: doc may be an Oj-generated Hash which is_a?(Hash) returns false for,
+        # so we use respond_to? for the hash-like protocol check.
         if name.nil? && doc.respond_to?(:key?) && doc.respond_to?(:values) && doc.size == 1
           attr_name = rule.to
           if doc.key?(attr_name.to_s) || doc.key?(attr_name.to_sym)