lutaml-model 0.8.9 → 0.8.10

data/lib/lutaml/xml/declaration_planner.rb

@@ -298,7 +298,7 @@ module Lutaml
       def build_collection_item_plans(collection, _mapping, _needs)
         children_plans = {}
 
-        return children_plans unless collection.respond_to?(:each)
+        return children_plans unless collection.is_a?(Array)
 
         # Get the item type from the collection class
         item_type = begin
@@ -595,7 +595,7 @@ mapper_class: nil)
 
         # Get child's element namespace if available
         child_type = attr_def.type(mapper_class ? register_for(mapper_class) : @register)
-        if child_type.respond_to?(:<) && child_type < Lutaml::Model::Serialize
+        if child_type.is_a?(Class) && child_type < Lutaml::Model::Serialize
           child_reg = register_for(child_type)
           child_mapping = child_type.mappings_for(:xml, child_reg)
           if child_mapping&.namespace_class
@@ -675,7 +675,7 @@ mapper_class: nil)
         # prefix declarations are NOT needed by any child element.
         if is_root && !options.key?(:use_prefix)
           stored_plan = options[:stored_xml_declaration_plan]
-          if stored_plan.respond_to?(:root_node) && stored_plan.root_node.respond_to?(:hoisted_declarations)
+          if stored_plan.is_a?(Lutaml::Xml::DeclarationPlan) && stored_plan.root_node.is_a?(Lutaml::Xml::DeclarationPlan::ElementNode)
             root_has_input_prefix = xml_element.xml_namespace_prefix.to_s != ""
 
             unless root_has_input_prefix
@@ -706,7 +706,7 @@ mapper_class: nil)
         #
         # Note: The transformation sets @needs_xmlns_blank on the XmlElement when the child
         # model has explicit `namespace :blank` declaration.
-        element_marked_blank = xml_element.respond_to?(:needs_xmlns_blank) && xml_element.needs_xmlns_blank
+        element_marked_blank = xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement) && xml_element.needs_xmlns_blank
 
         # Add xmlns="" when parent's effective namespace form is :qualified.
         # This implements the W3C XML Schema default behavior:
@@ -803,7 +803,7 @@ mapper_class: nil)
             if attr_def
               child_reg = mapper_class ? register_for(mapper_class) : @register
               child_type = attr_def.type(child_reg)
-              if child_type.respond_to?(:<) && child_type < Lutaml::Model::Serialize
+              if child_type.is_a?(Class) && child_type < Lutaml::Model::Serialize
                 child_type_reg = register_for(child_type)
                 child_mapping_obj = child_type.mappings_for(:xml,
                                                             child_type_reg)
@@ -1041,7 +1041,6 @@ mapper_class: nil)
           ns_key = xml_element.namespace_class.to_key
           ns_usage = needs.namespaces[ns_key]
           ns_from_wrapper = xml_element.is_a?(Lutaml::Xml::XmlElement) &&
-            xml_element.respond_to?(:namespace_prefix_explicit) &&
             xml_element.namespace_prefix_explicit
           if ns_from_wrapper
             used_prefix = ns_usage&.used_prefix
@@ -1195,7 +1194,7 @@ mapper_class: nil)
           # 3. Parent declared canonical/alias-A, child wants alias-B → NOT hoisted (child must declare its alias)
           # This ensures round-trip fidelity: if input used alias URI, output preserves it.
           ns_hoisted_by_parent = parent_hoisted.value?(ns_uri)
-          if !ns_hoisted_by_parent && ns_class.respond_to?(:all_uris) &&
+          if !ns_hoisted_by_parent && ns_class.is_a?(Class) && ns_class < Lutaml::Xml::Namespace &&
               ns_uri == ns_class.uri # child is using canonical URI
             # Parent declared an alias of this namespace — child doesn't need to re-declare
             # because the alias already establishes the namespace binding
@@ -1227,7 +1226,7 @@ mapper_class: nil)
             # Namespace is already hoisted by parent, and we have an explicit prefix
             # Check if parent has the SAME prefix declaration (accounting for URI aliases)
             parent_uri_for_prefix = parent_hoisted[element_prefix]
-            all_uris = ns_class.respond_to?(:all_uris) ? ns_class.all_uris : [ns_uri]
+            all_uris = ns_class.is_a?(Class) && ns_class < Lutaml::Xml::Namespace ? ns_class.all_uris : [ns_uri]
             parent_has_same_prefix = parent_uri_for_prefix && all_uris.include?(parent_uri_for_prefix)
             if parent_has_same_prefix
               # Parent already declared this namespace with the same prefix - don't re-declare
@@ -1256,7 +1255,7 @@ mapper_class: nil)
           # Use namespaces_at_path([]) to verify this namespace was actually at root level.
           # Note: namespace_locations only has child paths, not root. Root namespaces
           # are stored in root_node.hoisted_declarations, which namespaces_at_path returns.
-          if is_root && hoisted.key?(nil) && hoisted[nil] == ns_uri && xml_element.respond_to?(:children)
+          if is_root && hoisted.key?(nil) && hoisted[nil] == ns_uri && xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
             stored_plan = options[:stored_xml_declaration_plan]
             root_ns_at_input = stored_plan&.namespaces_at_path([])
             namespace_was_at_root = if root_ns_at_input
@@ -1405,7 +1404,7 @@ mapper_class: nil)
 
               # Only skip hoisting if child uses namespace AND parent doesn't use it for attributes
               # Check if parent element instance has attributes with this namespace
-              parent_has_attr_with_ns = if xml_element.respond_to?(:attributes)
+              parent_has_attr_with_ns = if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
                                           xml_element.attributes.any? do |xml_attr|
                                             next false unless xml_attr.namespace_class
 
@@ -1454,7 +1453,7 @@ mapper_class: nil)
               end
 
               # Only skip hoisting if child uses namespace AND parent doesn't use it for attributes
-              parent_has_attr_with_ns = if xml_element.respond_to?(:attributes)
+              parent_has_attr_with_ns = if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
                                           xml_element.attributes.any? do |xml_attr|
                                             next false unless xml_attr.namespace_class
 
@@ -1711,7 +1710,7 @@ mapper_class: nil)
 
         # Check all namespace classes in needs
         needs.all_namespace_classes.any? do |ns_class|
-          ns_class.respond_to?(:schema_location) && ns_class.schema_location
+          ns_class.is_a?(Class) && ns_class < Lutaml::Xml::Namespace && ns_class.schema_location
         end
       end
 
@@ -1829,7 +1828,7 @@ mapper_class: nil)
 
         # Collect all namespace classes that have schema_location
         namespaces_with_schema = needs.all_namespace_classes.select do |ns_class|
-          ns_class.respond_to?(:schema_location) && ns_class.schema_location
+          ns_class.is_a?(Class) && ns_class < Lutaml::Xml::Namespace && ns_class.schema_location
         end
 
         return nil if namespaces_with_schema.empty?

data/lib/lutaml/xml/document.rb

@@ -63,7 +63,7 @@ module Lutaml
       # @return [String, nil] the DOCTYPE declaration or nil if no DOCTYPE
       def doctype_declaration
         # Prefer native Nokogiri DOCTYPE
-        if @parsed_doc.respond_to?(:internal_subset) && @parsed_doc.internal_subset
+        if defined?(::Nokogiri) && @parsed_doc.is_a?(::Nokogiri::XML::Document) && @parsed_doc.internal_subset
           return "#{@parsed_doc.internal_subset}\n"
         end
 
@@ -97,15 +97,15 @@ module Lutaml
         result.attribute_order = element.attribute_order
 
         element.children.each do |child|
-          next if child.respond_to?(:comment?) && child.comment?
-          next if child.respond_to?(:processing_instruction?) && child.processing_instruction?
+          next if child.is_a?(Lutaml::Xml::XmlElement) && child.comment?
+          next if child.is_a?(Lutaml::Xml::XmlElement) && child.processing_instruction?
 
           if klass&.<= Serialize
             attr = klass.attribute_for_child(self.class.name_of(child),
                                              format)
           end
 
-          if child.respond_to?(:text?) && child.text?
+          if child.is_a?(Lutaml::Xml::XmlElement) && child.text?
             result.assign_or_append_value(
               self.class.name_of(child),
               self.class.text_of(child),
@@ -148,7 +148,7 @@ module Lutaml
       end
 
       def ordered?(element, options = {})
-        return false unless element.respond_to?(:element_order)
+        return false unless element.is_a?(Lutaml::Model::Serialize)
 
         mapper_class = options[:mapper_class]
         xml_mapping = mapper_class&.mappings_for(:xml)
@@ -198,7 +198,7 @@ module Lutaml
         return unless content_rule
 
         if content_rule.custom_methods[:to]
-          mapper_class.new.send(
+          mapper_class.new.public_send(
             content_rule.custom_methods[:to],
             element,
             xml.parent,
@@ -216,16 +216,16 @@ module Lutaml
         klass = mapper_class || element.class
         return klass.attributes[rule.to] unless rule.delegate
 
-        delegated_obj = element.send(rule.delegate)
+        delegated_obj = element.public_send(rule.delegate)
         return nil if delegated_obj.nil?
 
         delegated_obj.class.attributes[rule.to]
       end
 
       def attribute_value_for(element, rule)
-        return element.send(rule.to) unless rule.delegate
+        return element.public_send(rule.to) unless rule.delegate
 
-        element.send(rule.delegate).send(rule.to)
+        element.public_send(rule.delegate).public_send(rule.to)
       end
 
       def self.type
@@ -254,7 +254,7 @@ module Lutaml
         # For text + entity without elements, return joined String.
         has_element_children = @root.children.any? do |child|
           !child.text? && !entity_reference_node?(child) &&
-            !(child.respond_to?(:processing_instruction?) && child.processing_instruction?)
+            !(child.is_a?(Lutaml::Xml::XmlElement) && child.processing_instruction?)
         end
         return @root.text_children.map(&:text) if has_element_children
 
@@ -273,7 +273,7 @@ module Lutaml
         return false unless child.is_a?(Lutaml::Xml::NokogiriElement)
 
         node = child.adapter_node
-        node.respond_to?(:entity_reference?) && node.entity_reference?
+        defined?(::Nokogiri) && node.is_a?(::Nokogiri::XML::EntityReference) && node.entity_reference?
       end
 
       def setup_register(register)
@@ -281,7 +281,7 @@ module Lutaml
 
         return_register = if register.is_a?(Lutaml::Model::Register)
                             register.id
-                          elsif @root.respond_to?(:lutaml_register)
+                          elsif @root.is_a?(Lutaml::Model::Serialize)
                             @root.lutaml_register
                           end
         return_register || Lutaml::Model::Config.default_register
@@ -377,7 +377,7 @@ module Lutaml
                        ns_entry
                      end
 
-          ns_class.respond_to?(:uri) && ns_class.uri == namespace_uri
+          ns_class.is_a?(Class) && ns_class < Lutaml::Xml::XmlNamespace && ns_class.uri == namespace_uri
         end
       end
     end

data/lib/lutaml/xml/format_chooser.rb

@@ -60,7 +60,7 @@ module Lutaml
         # 3. Check if any child elements use :inherit
         # If they do and we have a prefix, use prefixed format
         # so children can properly reference the namespace
-        if mapping.namespace_class.prefix_default && mapping.respond_to?(:elements)
+        if mapping.namespace_class.prefix_default && mapping.is_a?(Lutaml::Xml::Mapping)
           has_inherit_children = mapping.elements.any? do |elem_rule|
             elem_rule.namespace_param == :inherit
           end
@@ -99,7 +99,7 @@ module Lutaml
         has_explicit_pref = options.key?(:prefix) || options.key?(:use_prefix)
         if !has_explicit_pref && options[:stored_xml_declaration_plan]
           stored_plan = options[:stored_xml_declaration_plan]
-          if stored_plan.respond_to?(:input_prefix_formats)
+          if stored_plan.is_a?(Lutaml::Xml::DeclarationPlan)
             # Check canonical URI and all aliases
             uris_to_check = [effective_ns_class.uri] + effective_ns_class.uri_aliases
             stored_plan.input_prefix_formats.each do |key, format|
@@ -165,7 +165,7 @@ module Lutaml
         end
 
         # 3. Check if any child elements use :inherit or form: :qualified
-        if effective_ns_class.prefix_default && mapping.respond_to?(:elements)
+        if effective_ns_class.prefix_default && mapping.is_a?(Lutaml::Xml::Mapping)
           has_inherit_children = mapping.elements.any? do |elem_rule|
             elem_rule.namespace_param == :inherit
           end

data/lib/lutaml/xml/hoisting_algorithm.rb

@@ -44,7 +44,7 @@ module Lutaml
 
         # Check if element or its descendants use a namespace
         def element_needs_namespace?(element, namespace_class)
-          return false unless element.respond_to?(:children)
+          return false unless element.is_a?(Lutaml::Xml::DataModel::XmlElement)
 
           element.children.each do |child|
             next unless child.is_a?(Lutaml::Xml::DataModel::XmlElement)

data/lib/lutaml/xml/mapping.rb

@@ -130,7 +130,7 @@ module Lutaml
         delegate = @content_mapping.delegate
         attr_def = if delegate
                      delegate_obj = mapper_class.attributes[delegate]
-                     delegate_obj&.type&.attributes&.dig(attr_name) if delegate_obj&.type.respond_to?(:attributes)
+                     delegate_obj&.type&.attributes&.dig(attr_name) if delegate_obj&.type.is_a?(Class) && delegate_obj&.type.include?(Lutaml::Model::Serialize)
                    else
                      mapper_class.attributes[attr_name]
                    end
@@ -638,7 +638,7 @@ module Lutaml
 
         if name == "schemaLocation"
           location = caller_locations(1, 1)[0]
-          caller_file = if defined?(File) && File.respond_to?(:basename)
+          caller_file = if defined?(File)
                           File.basename(location.path)
                         else
                           location.path.to_s.split("/").last

data/lib/lutaml/xml/mapping_rule.rb

@@ -90,6 +90,19 @@ module Lutaml
         !!@namespace_set
       end
 
+      # Pre-computed frozen Hash for the static namespace override case.
+      # Returns nil when no static override is needed — the caller should
+      # use the parent options directly, avoiding per-rule Hash allocation.
+      #
+      # Only rules with an explicit namespace (namespace_set? && != :inherit)
+      # produce a static override. The result is frozen and shared across
+      # all elements that evaluate this rule.
+      def static_namespace_option
+        return nil unless namespace_set? && @namespace_param != :inherit
+
+        @static_namespace_option ||= { default_namespace: namespace }.freeze
+      end
+
       def content_mapping?
         name.nil?
       end
@@ -215,14 +228,14 @@ module Lutaml
         ).tap do |dup_rule|
           # Manually preserve the exact @namespace_class object to avoid
           # recreating anonymous classes (which would have different object_ids)
-          dup_rule.send(:namespace_class=, @namespace_class)
+          dup_rule.namespace_class = @namespace_class
 
           # Manually ensure @namespace and @prefix are new string objects
           if dup_rule.namespace
-            dup_rule.send(:namespace=, dup_rule.namespace.dup)
+            dup_rule.namespace = dup_rule.namespace.dup
           end
           if dup_rule.prefix
-            dup_rule.send(:prefix=, dup_rule.prefix.dup)
+            dup_rule.prefix = dup_rule.prefix.dup
           end
         end
       end

data/lib/lutaml/xml/model_transform.rb

@@ -252,7 +252,7 @@ effective_register = nil, instance_is_serialize = nil)
         # Performance: Pre-build Set of child namespaced names for fast rule matching.
         # This allows skipping value_for_rule for ~91% of rules that have no matching child.
         child_names_set = nil
-        if doc.respond_to?(:element_children)
+        if doc.is_a?(::Lutaml::Xml::XmlElement) || doc.is_a?(::Lutaml::Xml::Document)
           ec = doc.element_children
           unless ec.empty?
             child_names_set = Set.new
@@ -268,7 +268,7 @@ effective_register = nil, instance_is_serialize = nil)
           rule.name
           rule_to = rule.to
           rule_namespace_set = rule.namespace_set?
-          rule_namespace_param = rule_namespace_set ? rule.namespace_param : nil
+          rule_namespace_set ? rule.namespace_param : nil
 
           attr = attribute_for_rule(rule)
           next if attr&.derived?
@@ -277,15 +277,14 @@ effective_register = nil, instance_is_serialize = nil)
             rule, attr
           )
 
-          # Performance: Only create new_opts when we need to override default_namespace
-          # Avoid dup for the common case where namespace is not set
-          new_opts = if rule_namespace_set && rule_namespace_param != :inherit
-                       { default_namespace: rule.namespace }
-                     elsif default_namespace.nil? && namespace_uri
-                       { default_namespace: namespace_uri }
-                     else
-                       options
-                     end
+          # Performance: Use pre-computed frozen Hash for static namespace overrides.
+          # Falls back to per-element hash only for the dynamic namespace_uri case.
+          new_opts = rule.static_namespace_option ||
+            if default_namespace.nil? && namespace_uri
+              { default_namespace: namespace_uri }
+            else
+              options
+            end
 
           value = if rule.raw_mapping?
                     doc.root.inner_xml
@@ -333,9 +332,6 @@ effective_register = nil, instance_is_serialize = nil)
           value = rule.transform_value(attr, value, :from, :xml)
           rule.deserialize(instance, value, attributes, context)
 
-          # Mark attribute as set from XML (not using default).
-          # Needed for instances created via allocate_for_deserialization
-          # which use Hash.new(true) as @using_default default.
           instance.value_set_for(rule_to)
         end
 
@@ -364,7 +360,7 @@ effective_register = nil, instance_is_serialize = nil)
 mixed_content_option, xml_mapping = nil,
 instance_is_serialize = nil)
         instance.element_order = doc.root.order
-        if doc.root.respond_to?(:attribute_order) && instance.respond_to?(:attribute_order=)
+        if instance_is_serialize && doc.root.is_a?(::Lutaml::Xml::XmlElement)
           instance.attribute_order = doc.root.attribute_order
         end
 
@@ -399,10 +395,12 @@ _effective_register)
         pi_mappings = xml_mapping.processing_instruction_mappings
         return if pi_mappings.empty?
 
-        doc_pis = if doc.respond_to?(:processing_instructions)
+        doc_pis = if doc.is_a?(::Lutaml::Xml::XmlElement)
                     doc.processing_instructions
-                  elsif doc.respond_to?(:root)
+                  elsif doc.is_a?(::Lutaml::Xml::Document)
                     doc.root.processing_instructions
+                  else
+                    []
                   end || []
 
         pi_attr = Lutaml::Xml::DataModel::XmlProcessingInstruction
@@ -427,7 +425,7 @@ _effective_register)
           next if value.nil?
 
           instance.public_send(:"#{pi_mapping.to}=", value)
-          instance.value_set_for(pi_mapping.to) if instance.respond_to?(:value_set_for)
+          instance.value_set_for(pi_mapping.to) if instance.is_a?(::Lutaml::Model::Serialize)
         end
       end
 
@@ -946,7 +944,7 @@ effective_register = lutaml_register)
           next unless collection.class.organization
 
           mappings = collection.class.mappings_for(:xml, register)
-          next unless mappings.respond_to?(:consolidation_maps)
+          next unless mappings.is_a?(::Lutaml::Xml::Mapping)
           next if mappings.consolidation_maps.empty?
 
           mappings.consolidation_maps.each do |map|

data/lib/lutaml/xml/namespace_collector.rb

@@ -61,15 +61,15 @@ module Lutaml
         needs = collect(nil, mapping)
 
         # If collection has instances, collect needs from instance type
-        if collection.respond_to?(:instances) &&
-            mapping.respond_to?(:find_element)
+        if collection.is_a?(Lutaml::Model::Collection) &&
+            mapping.is_a?(Lutaml::Xml::Mapping)
           instance_rule = mapping.find_element(:instances) ||
             mapping.elements.first
           if instance_rule
             attr_def = collection.class.attributes[instance_rule.to]
             if attr_def
               instance_type = attr_def.type(@register)
-              if instance_type.respond_to?(:<) &&
+              if instance_type.is_a?(Class) &&
                   instance_type < Lutaml::Model::Serialize
                 instance_mapping = instance_type.mappings_for(:xml)
                 if instance_mapping
@@ -314,7 +314,7 @@ module Lutaml
 
               # INSTANCE-AWARE COLLECTION
               if element
-                value = element.send(attr_rule.to) if element.respond_to?(attr_rule.to)
+                value = element.public_send(attr_rule.to) if element.is_a?(Lutaml::Model::Serialize) && element.class.attributes.key?(attr_rule.to)
                 next if value.nil? || ::Lutaml::Model::Utils.uninitialized?(value)
               end
 
@@ -346,7 +346,7 @@ module Lutaml
             # ==================================================================
             # PHASE 3: NAMESPACE_SCOPE CONFIGURATION
             # ==================================================================
-            if mapping.respond_to?(:namespace_scope_config) && mapping.namespace_scope_config&.any?
+            if mapping.is_a?(Lutaml::Xml::Mapping) && mapping.namespace_scope_config&.any?
               mapping.namespace_scope_config.each do |cfg|
                 config = NamespaceScopeConfig.new(cfg[:namespace],
                                                   cfg[:declare] || :auto)
@@ -374,8 +374,8 @@ module Lutaml
             next unless child_type
 
             # Get child instance BEFORE adding Type ref
-            child_instance = if element.respond_to?(elem_rule.to)
-                               element.send(elem_rule.to)
+            child_instance = if element.is_a?(Lutaml::Model::Serialize) && element.class.attributes.key?(elem_rule.to)
+                               element.public_send(elem_rule.to)
                              end
 
             # TYPE NAMESPACE INTEGRATION
@@ -390,7 +390,7 @@ module Lutaml
               needs.add_type_ref(ref)
             end
 
-            next unless child_type.respond_to?(:<) &&
+            next unless child_type.is_a?(Class) &&
               child_type < Lutaml::Model::Serialize
 
             # Get child mapping
@@ -541,7 +541,7 @@ module Lutaml
         end
 
         # Collect namespace_scope configuration from mapping
-        if mapping.respond_to?(:namespace_scope_config) && mapping.namespace_scope_config&.any?
+        if mapping.is_a?(Lutaml::Xml::Mapping) && mapping.namespace_scope_config&.any?
           mapping.namespace_scope_config.each do |cfg|
             config = NamespaceScopeConfig.new(cfg[:namespace],
                                               cfg[:declare] || :auto)
@@ -573,7 +573,7 @@ module Lutaml
                                    @register
                                  end
                 child_type = attr_def.type(child_register)
-                if child_type.respond_to?(:<) && child_type < Lutaml::Model::Serialize
+                if child_type.is_a?(Class) && child_type < Lutaml::Model::Serialize
                   child_mapping = child_type.mappings_for(:xml)
                   if child_mapping
                     # Recursively collect with child's mapping and register context

data/lib/lutaml/xml/namespace_declaration.rb

@@ -131,7 +131,7 @@ module Lutaml
       #
       # @return [Symbol] :qualified or :unqualified
       def element_form_default
-        if @ns_object.respond_to?(:element_form_default)
+        if @ns_object.is_a?(Class) && @ns_object < Lutaml::Xml::Namespace
           @ns_object.element_form_default
         else
           :qualified # W3C default
@@ -142,7 +142,7 @@ module Lutaml
       #
       # @return [Symbol] :qualified or :unqualified
       def attribute_form_default
-        if @ns_object.respond_to?(:attribute_form_default)
+        if @ns_object.is_a?(Class) && @ns_object < Lutaml::Xml::Namespace
           @ns_object.attribute_form_default
         else
           :unqualified # W3C default

data/lib/lutaml/xml/namespace_declaration_data.rb

@@ -94,7 +94,7 @@ module Lutaml
       # Get element_form_default setting
       # @return [Symbol] :qualified or :unqualified
       def element_form_default
-        if @namespace_class.respond_to?(:element_form_default)
+        if @namespace_class.is_a?(Class) && @namespace_class < Lutaml::Xml::Namespace
           @namespace_class.element_form_default
         else
           :qualified # W3C default
@@ -104,7 +104,7 @@ module Lutaml
       # Get attribute_form_default setting
       # @return [Symbol] :qualified or :unqualified
       def attribute_form_default
-        if @namespace_class.respond_to?(:attribute_form_default)
+        if @namespace_class.is_a?(Class) && @namespace_class < Lutaml::Xml::Namespace
           @namespace_class.attribute_form_default
         else
           :unqualified # W3C default
@@ -169,12 +169,9 @@ module Lutaml
         end
 
         # Validate that namespace class has required methods
-        unless @namespace_class.respond_to?(:uri)
-          raise ArgumentError, "Namespace class must respond to :uri"
-        end
-
-        unless @namespace_class.respond_to?(:to_key)
-          raise ArgumentError, "Namespace class must respond to :to_key"
+        unless @namespace_class.is_a?(Class) && @namespace_class < Lutaml::Xml::Namespace
+          raise ArgumentError,
+                "Namespace class must be a Lutaml::Xml::Namespace subclass"
         end
       end
     end

data/lib/lutaml/xml/namespace_scope_config.rb

@@ -100,8 +100,9 @@ module Lutaml
           raise ArgumentError, "Namespace class cannot be nil"
         end
 
-        unless @namespace_class.respond_to?(:to_key)
-          raise ArgumentError, "Namespace class must respond to :to_key"
+        unless @namespace_class.is_a?(Class) && @namespace_class < Lutaml::Xml::Namespace
+          raise ArgumentError,
+                "Namespace class must be a Lutaml::Xml::Namespace subclass"
         end
       end
     end

data/lib/lutaml/xml/namespace_type_resolver.rb

@@ -58,7 +58,7 @@ module Lutaml
       # @example Find all types in a namespace
       #   types = resolver.resolve_types_by_namespace("http://example.com/ns")
       def resolve_types_by_namespace(uri)
-        return [] unless context.respond_to?(:registry)
+        return [] unless context.is_a?(Lutaml::Model::TypeContext)
 
         context.registry.types.select do |_name, type_class|
           next false unless type_class <= Lutaml::Model::Type::Value
@@ -92,7 +92,7 @@ module Lutaml
         type_ns = type_class.namespace_class
         return nil unless type_ns
 
-        type_ns.respond_to?(:uri) ? type_ns.uri : nil
+        type_ns.is_a?(Class) && type_ns < Lutaml::Xml::Namespace ? type_ns.uri : nil
       end
 
       private
@@ -125,8 +125,8 @@ module Lutaml
         return true if ns1 == ns2
 
         # Compare by URI if both have it
-        uri1 = ns1.respond_to?(:uri) ? ns1.uri : nil
-        uri2 = ns2.respond_to?(:uri) ? ns2.uri : nil
+        uri1 = ns1.is_a?(Class) && ns1 < Lutaml::Xml::Namespace ? ns1.uri : nil
+        uri2 = ns2.is_a?(Class) && ns2 < Lutaml::Xml::Namespace ? ns2.uri : nil
 
         uri1 && uri2 && uri1 == uri2
       end

data/lib/lutaml/xml/nokogiri/element.rb

@@ -4,7 +4,7 @@ module Lutaml
   module Xml
     class NokogiriElement < AdapterElement
       def initialize(node, parent: nil, default_namespace: nil)
-        @raw_text = node.respond_to?(:raw_content) ? node.raw_content : nil if node.is_a?(Moxml::Text)
+        @raw_text = node.raw_content if node.is_a?(Moxml::Text)
         super
       end
 
@@ -27,7 +27,7 @@ module Lutaml
       end
 
       def attribute_value_for_build(attr)
-        attr.respond_to?(:raw_value) ? attr.raw_value : attr.value
+        attr.raw_value
       end
     end
   end

data/lib/lutaml/xml/polymorphic_value_handler.rb

@@ -23,7 +23,7 @@ module Lutaml
       # @return [Boolean] true if value should use polymorphic serialization
       def polymorphic_value?(attribute, value)
         return false unless attribute
-        return false unless value.respond_to?(:class)
+        return false unless value
 
         # Check if attribute explicitly declares polymorphism
         return true if attribute.options[:polymorphic] || attribute.polymorphic?

data/lib/lutaml/xml/schema/xsd/base.rb

@@ -84,13 +84,13 @@ module Lutaml
           end
 
           def min_occurrences
-            return unless respond_to?(:min_occurs)
+            return unless is_a?(Element) || is_a?(Group) || is_a?(Any)
 
             @min_occurs&.to_i || 1
           end
 
           def max_occurrences
-            return unless respond_to?(:max_occurs)
+            return unless is_a?(Element) || is_a?(Group) || is_a?(Any)
             return "*" if @max_occurs == "unbounded"
 
             @max_occurs&.to_i || 1
@@ -106,13 +106,13 @@ module Lutaml
 
             seen[self] = true
             resolved_element_order&.each do |element|
-              if element.respond_to?(:ref) && element.ref
+              if element.is_a?(Element) && element.ref
                 if resolvable_reference?(element.ref)
                   element.referenced_object&.unresolvable_items(array, seen)
                 else
                   array << element
                 end
-              elsif element.respond_to?(:unresolvable_items)
+              elsif element.is_a?(Base)
                 element.unresolvable_items(array, seen)
               end
             end
@@ -174,7 +174,7 @@ module Lutaml
           end
 
           def find_object_for_ref(reference)
-            if respond_to?(:referenced_object)
+            if is_a?(Element) || is_a?(Group) || is_a?(AttributeGroup) || is_a?(Attribute) || is_a?(ExtensionComplexContent)
               referenced_object
             else
               find_object(collection_for_reference(reference), reference)
@@ -196,14 +196,14 @@ module Lutaml
               next unless element == instance
 
               method_name = ::Lutaml::Model::Utils.snake_case(instance.name)
-              array[i] = Array(send(method_name))[index]
+              array[i] = Array(public_send(method_name))[index]
               index += 1
             end
           end
 
           def assign_root_value!(value, root, seen)
             Array(value).each do |child|
-              next unless child.respond_to?(:assign_root!)
+              next unless child.is_a?(Base)
 
               child_root = child.is_a?(Schema) ? child : root
               child.assign_root!(child_root, seen)