lutaml-model 0.8.9 → 0.8.11

data/lib/lutaml/key_value/transformation/collection_serializer.rb

@@ -175,10 +175,14 @@ options = {})
           items.each do |item|
             next if item.nil?
 
-            key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+            key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                          item.public_send(key_attribute)
+                        end
             next if key_value.nil?
 
-            attr_value = item.respond_to?(value_attribute) ? item.public_send(value_attribute) : nil
+            attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(value_attribute)
+                           item.public_send(value_attribute)
+                         end
             next if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
             # Get the attribute definition for the value attribute
@@ -193,7 +197,7 @@ options = {})
               item_mapping = item_class.mappings_for(format, register_id)
               item_mapping&.mappings&.each do |mapping_rule|
                 if mapping_rule.to == value_attribute
-                  child_mappings = mapping_rule.child_mappings if mapping_rule.respond_to?(:child_mappings)
+                  child_mappings = mapping_rule.child_mappings
                   break
                 end
               end
@@ -226,7 +230,9 @@ options)
 
           keyed_hash = {}
           items.each do |item|
-            key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+            key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                          item.public_send(key_attribute)
+                        end
             next if key_value.nil?
 
             item_hash = {}
@@ -281,7 +287,9 @@ options)
           items.each do |item|
             next if item.nil?
 
-            key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+            key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                          item.public_send(key_attribute)
+                        end
             next if key_value.nil?
 
             item_hash = {}
@@ -340,7 +348,9 @@ options)
           value_attribute = find_value_attribute(child_mappings)
 
           items.each do |item|
-            key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+            key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                          item.public_send(key_attribute)
+                        end
             next if key_value.nil?
 
             if value_attribute
@@ -371,7 +381,9 @@ options)
         # Serialize a keyed collection item with value mapping.
         def serialize_keyed_value_item(keyed_hash, item, key_value,
                                        value_attribute, options)
-          attr_value = item.respond_to?(value_attribute) ? item.public_send(value_attribute) : nil
+          attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(value_attribute)
+                         item.public_send(value_attribute)
+                       end
           return if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
           item_class = item.class
@@ -419,7 +431,9 @@ options)
           child_mappings.each do |attr_name, path_spec|
             next if %i[key value].include?(path_spec)
 
-            attr_value = item.respond_to?(attr_name) ? item.public_send(attr_name) : nil
+            attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(attr_name)
+                           item.public_send(attr_name)
+                         end
             next if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
             attr_def = nil
@@ -508,7 +522,7 @@ options)
             serialize_collection_value(value, attr_type, options)
           elsif attr_type.is_a?(Class) && attr_type < Lutaml::Model::Serialize
             serialize_nested_model(value, attr_type, options)
-          elsif attr_type.respond_to?(:new)
+          elsif attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
             serialize_primitive(value, attr_type)
           else
             value
@@ -523,7 +537,7 @@ options)
           # Handle Reference type collections - serialize each as a key
           if attr_type == Lutaml::Model::Type::Reference
             return items.map do |item|
-              item.respond_to?(:"to_#{format}") ? item.send(:"to_#{format}") : item
+              item.is_a?(Lutaml::Model::Type::Value) ? item.public_send(:"to_#{format}") : item
             end
           end
 
@@ -547,7 +561,7 @@ options)
         # Serialize a primitive value.
         def serialize_primitive(value, attr_type)
           wrapped_value = attr_type.new(value)
-          wrapped_value.send(:"to_#{format}")
+          wrapped_value.public_send(:"to_#{format}")
         end
 
         # Create a transformation for a type class.

data/lib/lutaml/key_value/transformation/value_serializer.rb

@@ -128,13 +128,13 @@ model_class: nil)
           if rule.attribute_type.is_a?(Class) &&
               rule.attribute_type < Lutaml::Model::Serialize
             validate_serializable_type!(value, rule)
-            return value.send(:"to_#{format}")
+            return value.public_send(:"to_#{format}")
           end
 
           # Wrap value in type and call to_#{format}
-          if rule.attribute_type.respond_to?(:new)
+          if rule.attribute_type.is_a?(Class) && rule.attribute_type < Lutaml::Model::Type::Value
             wrapped_value = rule.attribute_type.new(value)
-            wrapped_value.send(:"to_#{format}")
+            wrapped_value.public_send(:"to_#{format}")
           else
             value
           end
@@ -152,7 +152,7 @@ model_class: nil)
           subs = context.substitution_for(rule.attribute_type)
           uses_type_substitution = subs.any? { |s| s.to_type == value.class }
 
-          if rule.attribute_type.respond_to?(:model) && rule.attribute_type.model
+          if rule.attribute_type.is_a?(Class) && rule.attribute_type.include?(Lutaml::Model::Serialize) && rule.attribute_type.model
             # Mapper class: value should be an instance of the mapped model
             unless value.is_a?(rule.attribute_type.model) || uses_type_substitution
               msg = "attribute '#{rule.attribute_name}' value is a '#{value.class}' " \
@@ -227,7 +227,7 @@ model_class: nil)
         # @param rule [CompiledRule] The compiled rule
         # @return [Boolean] true if Reference type
         def reference_type?(rule)
-          return false unless rule.respond_to?(:attribute_name)
+          return false unless rule.is_a?(Lutaml::Model::CompiledRule)
           return false unless model_class
 
           # Get the attribute from the model class to check unresolved_type
@@ -256,8 +256,8 @@ model_class: nil)
           end
 
           # Fallback: just call to_format on the value
-          if value.respond_to?(:"to_#{format}")
-            value.send(:"to_#{format}")
+          if value.is_a?(Lutaml::Model::Type::Value) || value.is_a?(Lutaml::Model::Serialize)
+            value.public_send(:"to_#{format}")
           else
             value
           end

data/lib/lutaml/key_value/transformation.rb

@@ -209,8 +209,8 @@ register = self.register)
         # Handle custom serialization methods (e.g., with: { to: ... })
         if rule.has_custom_methods? && rule.custom_methods[:to]
           # Call custom method which directly modifies the parent element
-          return model_instance.send(rule.custom_methods[:to],
-                                     model_instance, parent)
+          return model_instance.public_send(rule.custom_methods[:to],
+                                            model_instance, parent)
         end
 
         # Handle delegation - extract value from delegated object
@@ -357,11 +357,15 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
               next if item.nil?
 
               # Get the key value from the item
-              key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+              key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                            item.public_send(key_attribute)
+                          end
               next if key_value.nil?
 
               # Get the value from the item
-              attr_value = item.respond_to?(value_attribute) ? item.public_send(value_attribute) : nil
+              attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(value_attribute)
+                             item.public_send(value_attribute)
+                           end
               next if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
               # For the value, we need to transform it appropriately
@@ -419,7 +423,7 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
                                                              item_class_mapping, format, register)
 
                   # Find the rule for the value_attribute in the item's class mapping
-                  item_rule = item_class_transformation.send(:compiled_rules).find do |r|
+                  item_rule = item_class_transformation.compiled_rules.find do |r|
                     r.attribute_name == value_attribute
                   end
 
@@ -460,8 +464,9 @@ converted_from_empty_to_nil: false, converted_from_nil_to_empty: false)
             items.each do |item|
               next if item.nil?
 
-              # Get the key value from the item
-              key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+              key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                            item.public_send(key_attribute)
+                          end
               next if key_value.nil?
 
               # Serialize all attributes except the key
@@ -573,7 +578,9 @@ child_mappings, options)
 
         items.each do |item|
           # Get the key value from the item
-          key_value = item.respond_to?(key_attribute) ? item.public_send(key_attribute) : nil
+          key_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(key_attribute)
+                        item.public_send(key_attribute)
+                      end
 
           if ENV["DEBUG_KEYED_COLLECTION"]
             puts "  item: #{item.inspect}, key_value=#{key_value.inspect}"
@@ -583,7 +590,9 @@ child_mappings, options)
 
           # If there's a value mapping, serialize just that attribute value
           if value_attribute
-            attr_value = item.respond_to?(value_attribute) ? item.public_send(value_attribute) : nil
+            attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(value_attribute)
+                           item.public_send(value_attribute)
+                         end
             next if attr_value.nil? || Lutaml::Model::Utils.uninitialized?(attr_value)
 
             # Get the attribute definition for proper serialization
@@ -637,7 +646,9 @@ child_mappings, options)
                 next if path_spec == :value
 
                 # Get the attribute value
-                attr_value = item.respond_to?(attr_name) ? item.public_send(attr_name) : nil
+                attr_value = if item.is_a?(Lutaml::Model::Serialize) && item.class.attributes.key?(attr_name)
+                               item.public_send(attr_name)
+                             end
 
                 if ENV["DEBUG_KEYED_COLLECTION"]
                   puts "    #{attr_name}: path_spec=#{path_spec.inspect}, attr_value=#{attr_value.inspect}"
@@ -833,10 +844,9 @@ child_mappings, options)
           child_hash = child_root.to_hash
           child_hash["__root__"]
         # Use the transformation to serialize the nested model
-        elsif attr_type.respond_to?(:new)
-          # Serialize primitive value
+        elsif attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
           wrapped_value = attr_type.new(value)
-          wrapped_value.send(:"to_#{format}")
+          wrapped_value.public_send(:"to_#{format}")
         else
           value
         end
@@ -940,7 +950,7 @@ child_mappings, options)
           subs = context.substitution_for(rule.attribute_type)
           uses_type_substitution = subs.any? { |s| s.to_type == value.class }
 
-          if rule.attribute_type.respond_to?(:model) && rule.attribute_type.model
+          if rule.attribute_type.is_a?(Class) && rule.attribute_type.include?(Lutaml::Model::Serialize) && rule.attribute_type.model
             # Mapper class: value should be an instance of the mapped model
             # or a valid substituted type
             unless value.is_a?(rule.attribute_type.model) || uses_type_substitution
@@ -1054,14 +1064,14 @@ child_mappings, options)
           end
 
           # Value is a valid Serialize instance - serialize it using its own to_#{format} method
-          return value.send(:"to_#{format}")
+          return value.public_send(:"to_#{format}")
         end
 
         # Wrap value in type and call to_#{format} instance method (like legacy Attribute#serialize_value)
         # This allows custom type subclasses to override to_json, to_yaml, etc.
-        if rule.attribute_type.respond_to?(:new)
+        if rule.attribute_type.is_a?(Class) && rule.attribute_type < Lutaml::Model::Type::Value
           wrapped_value = rule.attribute_type.new(value)
-          wrapped_value.send(:"to_#{format}")
+          wrapped_value.public_send(:"to_#{format}")
         else
           value
         end

data/lib/lutaml/model/adapter_resolver.rb

@@ -225,7 +225,7 @@ module Lutaml
         # @param type [String] normalized type name
         def load_adapter_file(adapter, type)
           loader = FormatRegistry.adapter_loader_for(adapter.to_sym)
-          if loader.respond_to?(:load_adapter_file)
+          if loader
             loader.load_adapter_file(adapter, type)
             return
           end
@@ -248,10 +248,8 @@ module Lutaml
         # @param format [Symbol] format name
         def load_moxml_adapter(type_name, format)
           loader = FormatRegistry.adapter_loader_for(format)
-          if loader.respond_to?(:load_moxml_adapter)
-            loader.load_moxml_adapter(type_name,
-                                      format)
-          end
+          loader&.load_moxml_adapter(type_name,
+                                     format)
         end
 
         # Resolve the adapter class from the type name.
@@ -261,7 +259,7 @@ module Lutaml
         # @return [Class] the adapter class
         def class_for(adapter, type)
           loader = FormatRegistry.adapter_loader_for(adapter.to_sym)
-          if loader.respond_to?(:class_for)
+          if loader
             return loader.class_for(adapter, type)
           end
 

data/lib/lutaml/model/attribute.rb

@@ -36,20 +36,8 @@ module Lutaml
         :string,
       ].freeze
 
-      # Keys that are safe to propagate from parent to child deserialization.
-      # Parent-internal keys (namespace_uri, resolved_type, converted) are
-      # intentionally excluded — children must derive their own context.
-      CHILD_PROPAGATION_KEYS = %i[
-        lutaml_parent
-        lutaml_root
-        default_namespace
-        import_declaration_plan
-        polymorphic
-        collection
-        render_empty
-        render_nil
-        cdata
-      ].freeze
+      # Delegate propagation to DeserializationContext for single source of truth.
+      CHILD_PROPAGATION_KEYS = Serialize::DeserializationContext::PROPAGATION_KEYS
 
       # Methods where accidental override is likely to cause issues
       # All names are allowed - this list only controls which ones get a warning
@@ -590,9 +578,10 @@ instance_object = nil)
                           type(register)
                         end
         if collection_instance?(value) || value.is_a?(Array)
+          merged_opts = options.merge(resolved_type: resolved_type,
+                                      converted: true)
           return build_collection(value.map do |v|
-            cast(v, format, register,
-                 options.merge(resolved_type: resolved_type, converted: true))
+            cast(v, format, register, merged_opts)
           end)
         end
 
@@ -616,11 +605,11 @@ instance_object = nil)
 
         klass = resolve_polymorphic_class(resolved_type, value, options)
         if can_serialize?(klass, value, format, options)
-          propagated = options.slice(*CHILD_PROPAGATION_KEYS)
+          propagated = Serialize::DeserializationContext.propagate(options)
           klass.apply_mappings(value, format,
                                propagated.merge(register: register))
         elsif needs_conversion?(klass, value)
-          klass.send(:"from_#{format}", value)
+          klass.public_send(:"from_#{format}", value)
         else
           # No need to use register#get_class,
           # can_serialize? method already checks if type is Serializable or not.
@@ -711,9 +700,7 @@ instance_object = nil)
         # Skip validation during deep_dup - options are already validated in original
         # This prevents infinite recursion when process_options! tries to access collection
         self.class.new(name, unresolved_type, duped_options).tap do |dup_attr|
-          # Copy already-processed instance variables directly
-          dup_attr.send(:raw=, @raw)
-          dup_attr.send(:validations=, @validations)
+          dup_attr.copy_internal_state_from(self)
         end
       end
 
@@ -765,6 +752,22 @@ instance_object = nil)
         type_namespace_class(register)&.prefix_default
       end
 
+      # Copy internal state from another Attribute instance.
+      # Used by `dup` to transfer processed state without calling private writers.
+      def copy_internal_state_from(source)
+        @raw = source.raw?
+        @validations = source.validations
+      end
+
+      # Clear type resolution caches for this attribute.
+      # Called by GlobalContext.clear_caches to ensure stale entries
+      # from GC'd TypeContext objects don't persist.
+      def clear_type_cache
+        @type_cache&.clear
+        @cached_type_default = nil
+        @default_type_context = nil
+      end
+
       private
 
       attr_writer :raw, :validations
@@ -852,7 +855,7 @@ instance_object = nil)
                            register
                          end
 
-        as_options = options.slice(*CHILD_PROPAGATION_KEYS).merge(register: value_register)
+        as_options = Serialize::DeserializationContext.propagate(options).merge(register: value_register)
 
         # Respect mapping layer policy: render_empty from MappingRule
         # Allow empty Serializable models when render_empty: true
@@ -874,7 +877,7 @@ instance_object = nil)
 
       def serialize_value(value, format, resolved_type)
         value = wrap_in_type_if_needed(value, resolved_type)
-        value.send(:"to_#{format}")
+        value.public_send(:"to_#{format}")
       end
 
       def wrap_in_type_if_needed(value, resolved_type)

data/lib/lutaml/model/cached_type_resolver.rb

@@ -63,10 +63,11 @@ module Lutaml
       # @return [Class] The resolved type class
       # @raise [UnknownTypeError] If type cannot be resolved
       def resolve(name, context)
-        # Fast path: Class types are passed through directly (no caching needed)
-        return @delegate.resolve(name, context) if name.is_a?(Class)
-
-        cache_key = build_cache_key(name, context)
+        cache_key = if name.is_a?(Class)
+                      [context.id, name]
+                    else
+                      build_cache_key(name, context)
+                    end
 
         @cache_backend.fetch_or_store(cache_key) do
           @delegate.resolve(name, context)
@@ -79,14 +80,14 @@ module Lutaml
       # @param context [TypeContext] The resolution context
       # @return [Boolean] true if type can be resolved
       def resolvable?(name, context)
-        return true if name.is_a?(Class)
-
-        cache_key = build_cache_key(name, context)
+        cache_key = if name.is_a?(Class)
+                      [context.id, name]
+                    else
+                      build_cache_key(name, context)
+                    end
 
-        # Check cache first (fast path)
         return true if @cache_backend.key?(cache_key)
 
-        # Not in cache - delegate
         @delegate.resolvable?(name, context)
       end
 

data/lib/lutaml/model/cli.rb

@@ -70,7 +70,7 @@ module Lutaml
         format = path.split(".").last.downcase
         format = "yaml" if format == "yml"
 
-        model.send("from_#{format}", content)
+        model.public_send("from_#{format}", content)
       rescue StandardError => e
         raise StandardError, "Error parsing file #{path}: #{e.message}"
       end

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