lutaml-model 0.8.9 → 0.8.10

data/lib/lutaml/model/collection.rb

@@ -292,7 +292,7 @@ module Lutaml
             !ctx.stopped?
           }) do |collection, errors, ctx|
             missing_items = collection.select do |instance|
-              value = instance.respond_to?(field) ? instance.public_send(field) : nil
+              value = instance.is_a?(Serialize) ? instance.public_send(field) : nil
               Utils.blank?(value)
             end
 
@@ -420,7 +420,7 @@ module Lutaml
         end
 
         def extract_field_value(instance, field)
-          instance.respond_to?(field) ? instance.public_send(field) : nil
+          instance.is_a?(Serialize) ? instance.public_send(field) : nil
         end
 
         def add_uniqueness_error(errors, field, duplicates, message)
@@ -553,7 +553,7 @@ lutaml_register: Lutaml::Model::Config.default_register)
             key = if field_or_proc.is_a?(Proc)
                     field_or_proc.call(item)
                   else
-                    item.send(field_or_proc)
+                    item.public_send(field_or_proc)
                   end
             @index_caches[name][key] = item
           end
@@ -591,7 +591,7 @@ lutaml_register: Lutaml::Model::Config.default_register)
         if field.is_a?(Proc)
           collection.sort_by!(&field)
         else
-          collection.sort_by! { |item| item.send(field) }
+          collection.sort_by! { |item| item.public_send(field) }
         end
       end
 

data/lib/lutaml/model/comparable_model.rb

@@ -19,10 +19,10 @@ module Lutaml
 
         compared_objects[comparison_key(other)] = true
         self.class.attributes.all? do |attr, _|
-          attr_value = send(attr)
-          other_value = other.send(attr)
+          attr_value = public_send(attr)
+          other_value = other.public_send(attr)
 
-          if attr_value.respond_to?(:eql?) && same_class?(attr_value)
+          if attr_value.is_a?(ComparableModel) && same_class?(attr_value)
             attr_value.eql?(other_value, compared_objects)
           else
             attr_value == other_value
@@ -59,9 +59,9 @@ module Lutaml
 
       def attributes_hash(processed_objects)
         self.class.attributes.map do |attr, _|
-          attr_value = send(attr)
+          attr_value = public_send(attr)
 
-          if attr_value.respond_to?(:calculate_hash)
+          if attr_value.is_a?(ComparableModel)
             attr_value.calculate_hash(processed_objects)
           else
             attr_value.hash
@@ -205,7 +205,7 @@ module Lutaml
           return yield nil, nil, obj1, obj2, true if obj1.class != obj2.class
 
           obj1.class.attributes.each_with_index do |(name, type), index|
-            yield name, type, obj1.send(name), obj2.send(name), index == obj1.class.attributes.length - 1
+            yield name, type, obj1.public_send(name), obj2.public_send(name), index == obj1.class.attributes.length - 1
           end
         end
 
@@ -398,7 +398,7 @@ module Lutaml
           return format_value(obj) unless obj.is_a?(ComparableModel)
 
           obj.class.attributes.map do |attr, _|
-            "#{attr}: #{format_value(obj.send(attr))}"
+            "#{attr}: #{format_value(obj.public_send(attr))}"
           end.join("\n")
         end
 
@@ -426,7 +426,7 @@ module Lutaml
         def type_name(type)
           if type.is_a?(Class)
             type.name
-          elsif type.respond_to?(:type)
+          elsif type.is_a?(Attribute)
             type.type.name
           else
             type.class.name
@@ -439,8 +439,8 @@ module Lutaml
         # @return [String] Formatted attributes of the objects
         def format_object_attributes(obj1, obj2, parent_node)
           obj1.class.attributes.each_key do |attr|
-            value1 = obj1.send(attr)
-            value2 = obj2.send(attr) if obj2.respond_to?(attr)
+            value1 = obj1.public_send(attr)
+            value2 = obj2.public_send(attr)
 
             attr_type = obj1.class.attributes[attr].collection? ? "collection" : type_name(obj1.class.attributes[attr])
 
@@ -525,7 +525,7 @@ type_info = nil)
         # @return [String] Formatted ComparableModel object
         def format_comparable_mapper(obj, parent_node, color = nil)
           obj.class.attributes.each do |attr_name, attr_type|
-            attr_value = obj.send(attr_name)
+            attr_value = obj.public_send(attr_name)
             attr_node = Tree.new("#{attr_name} (#{type_name(attr_type)}):",
                                  color: color)
             parent_node.add_child(attr_node)

data/lib/lutaml/model/config.rb

@@ -125,7 +125,7 @@ module Lutaml
       #
       # @param format [Symbol] the format name
       def define_adapter_type_methods(format)
-        return if respond_to?(:"#{format}_adapter_type=")
+        return if method_defined?(:"#{format}_adapter_type=")
 
         # Adapter class getter (returns Class)
         define_method(:"#{format}_adapter") do

data/lib/lutaml/model/consolidation/dispatcher.rb

@@ -31,7 +31,7 @@ module Lutaml
 
           value = if target_type == item.class
                     item
-                  elsif item.respond_to?(:value)
+                  elsif item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(:value)
                     item.value
                   else
                     item

data/lib/lutaml/model/consolidation/pattern_chunker.rb

@@ -53,7 +53,7 @@ module Lutaml
         # @param token [Object] a mixed content token
         # @return [Symbol] :element or :text
         def token_type(token)
-          if token.respond_to?(:node_type)
+          if token.is_a?(Lutaml::Xml::XmlElement)
             token.node_type == :element ? :element : :text
           elsif token.is_a?(Hash)
             token[:type] || (token.key?(:text) ? :text : :element)
@@ -65,7 +65,7 @@ module Lutaml
         # @param token [Object] a mixed content token
         # @return [String, nil] the element name
         def token_name(token)
-          if token.respond_to?(:name)
+          if token.is_a?(Lutaml::Xml::XmlElement)
             token.name
           elsif token.is_a?(Hash)
             token[:name]
@@ -75,7 +75,7 @@ module Lutaml
         # @param token [Object] a mixed content token
         # @return [String, nil] the text content
         def token_text(token)
-          if token.respond_to?(:text)
+          if token.is_a?(Lutaml::Xml::XmlElement)
             token.text
           elsif token.is_a?(Hash)
             token[:text]

data/lib/lutaml/model/format_registry.rb

@@ -163,10 +163,12 @@ module Lutaml
           end
 
           # Aliased _type methods
-          cfg.send(:alias_method, :"#{format}_adapter_type=",
-                   :"#{format}_adapter=")
-          cfg.send(:alias_method, :"#{format}_adapter_type",
-                   :"#{format}_adapter")
+          cfg.class_eval do
+            alias_method :"#{format}_adapter_type=", :"#{format}_adapter="
+          end
+          cfg.class_eval do
+            alias_method :"#{format}_adapter_type", :"#{format}_adapter"
+          end
         end
 
         # Derive a symbol adapter name from an adapter class.

data/lib/lutaml/model/global_context.rb

@@ -181,7 +181,7 @@ module Lutaml
           @resolver.clear_all_caches
           @imports.reset!
           @format_registries.each_value do |reg|
-            reg.clear! if reg.respond_to?(:clear!)
+            reg.clear! if reg.is_a?(FormatRegistry)
           end
           @namespace_register_map.clear
           @default_context_id = :default
@@ -227,7 +227,7 @@ module Lutaml
       # @return [void]
       def clear_format_registry!(format)
         reg = @format_registries[format]
-        reg&.clear! if reg.respond_to?(:clear!)
+        reg&.clear! if reg.is_a?(FormatRegistry)
       end
 
       # Backward-compatible accessor for XML namespace registry.

data/lib/lutaml/model/global_register.rb

@@ -86,7 +86,7 @@ module Lutaml
         if ctx
           ctx.registry.names.each do |name|
             model_class = ctx.registry.lookup(name)
-            if model_class.respond_to?(:clear_cache)
+            if model_class.is_a?(Class) && model_class.include?(Lutaml::Model::Serialize)
               model_class.clear_cache(register_id)
             end
           end

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