lutaml-model 0.8.9 → 0.8.10

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)

data/lib/lutaml/model/store.rb

@@ -36,8 +36,8 @@ module Lutaml
 
       def initialize
         @store = ::Hash.new { |hash, key| hash[key] = [] }
-        # Lazy index: built on first resolve for a given (class, key) pair.
-        # Key: [class_name, reference_method] → { value => WeakRef(object) }
+        # Nested index: { model_key => { reference_key => { value => WeakRef(object) } } }
+        # Grouped by model_key so register only iterates this class's own indices.
         @index = {}
       end
 
@@ -53,23 +53,17 @@ module Lutaml
 
       def resolve(model_class, reference_key, reference_value)
         model_key = model_class.to_s
-        index_key = [model_key, reference_key]
+        model_indices = @index[model_key]
 
-        # Build index lazily on first resolve for this (class, key) pair
-        unless @index.key?(index_key)
-          ensure_index(index_key, model_key,
-                       reference_key)
+        unless model_indices&.key?(reference_key)
+          model_indices = ensure_model_index(model_key)
+          build_index(model_indices, model_key, reference_key)
         end
 
-        # O(1) indexed lookup
-        entry = @index[index_key][reference_value]
+        entry = model_indices[reference_key][reference_value]
         return nil unless entry
 
-        begin
-          entry.__getobj__ if entry.weakref_alive?
-        rescue WeakRef::RefError
-          nil
-        end
+        dereference(entry)
       end
 
       def clear
@@ -89,9 +83,13 @@ module Lutaml
 
       private
 
+      def ensure_model_index(model_key)
+        @index[model_key] ||= {}
+      end
+
       # Build index for a (model_class, reference_key) pair by scanning existing instances.
-      def ensure_index(index_key, model_key, reference_key)
-        entries = @index[index_key] = {}
+      def build_index(model_indices, model_key, reference_key)
+        entries = model_indices[reference_key] = {}
         @store[model_key]&.each do |ref|
           obj = ref.__getobj__
           value = obj.public_send(reference_key)
@@ -101,19 +99,27 @@ module Lutaml
         end
       end
 
-      # Update indices that already exist for this model class.
+      # Update indices that already exist for this model class only.
+      # O(K) where K = number of reference keys indexed for this class,
+      # not O(N×K) across all classes.
       def update_existing_indices(object, model_key)
-        @index.each do |index_key, entries|
-          next unless index_key[0] == model_key
+        model_indices = @index[model_key]
+        return unless model_indices
 
-          key_method = index_key[1]
-          value = object.public_send(key_method)
+        model_indices.each do |reference_key, entries|
+          value = object.public_send(reference_key)
           entries[value] = WeakRef.new(object) if value
         rescue WeakRef::RefError
           next
         end
       end
 
+      def dereference(entry)
+        entry.__getobj__ if entry.weakref_alive?
+      rescue WeakRef::RefError
+        nil
+      end
+
       def compact_if_needed(refs)
         return unless refs.size > COMPACTION_THRESHOLD
 

data/lib/lutaml/model/transformation_registry.rb

@@ -185,7 +185,7 @@ module Lutaml
         # Build mapping OUTSIDE any lock to avoid deadlock
         # (ensure_mappings_imported! may recursively call get_or_build_mapping)
         mapping = model_class.mappings[format]
-        mapping = mapping || model_class.send(:default_mappings, format)
+        mapping = mapping || model_class.default_mappings(format)
 
         mapping.ensure_mappings_imported!(register_id)
 

data/lib/lutaml/model/type_context.rb

@@ -47,6 +47,9 @@ module Lutaml
       # @return [Array<TypeSubstitution>] Type substitution rules
       attr_reader :substitutions
 
+      # @return [Hash{Class => Class}] Pre-built Hash for O(1) substitution lookup
+      attr_reader :substitution_hash
+
       # @return [Array<TypeContext>] Fallback contexts (in order)
       attr_reader :fallback_contexts
 
@@ -60,6 +63,9 @@ module Lutaml
         @id = id.to_sym
         @registry = registry
         @substitutions = Array(substitutions).freeze
+        @substitution_hash = @substitutions.to_h do |s|
+          [s.from_type, s.to_type]
+        end.freeze
         @fallback_contexts = Array(fallback_contexts).freeze
         freeze
       end
@@ -254,7 +260,7 @@ module Lutaml
           ctx
         when Symbol, String
           # Try to look up from GlobalContext if available
-          if defined?(GlobalContext) && GlobalContext.respond_to?(:registry)
+          if defined?(GlobalContext)
             GlobalContext.registry.lookup(ctx)
           end
         end

data/lib/lutaml/model/type_resolver.rb

@@ -157,12 +157,7 @@ module Lutaml
       def self.apply_substitutions(type, context)
         return type if context.nil? || context.substitutions.empty?
 
-        context.substitutions.each do |sub|
-          substituted = sub.apply(type)
-          return substituted if substituted
-        end
-
-        type
+        context.substitution_hash[type] || type
       end
 
       # Get all available type names from context and fallbacks.

data/lib/lutaml/model/utils.rb

@@ -163,12 +163,25 @@ module Lutaml
         #   fetch_str_or_sym(hash, :key) # => "value"
         #   fetch_str_or_sym(hash, "invalid_key") # => nil
         def fetch_str_or_sym(hash, key, default = nil)
-          if hash.key?(key.to_s)
-            hash[key.to_s]
-          elsif hash.key?(key.to_sym)
-            hash[key.to_sym]
+          case key
+          when String
+            if hash.key?(key)
+              hash[key]
+            else
+              (hash.key?(key.to_sym) ? hash[key.to_sym] : default)
+            end
+          when Symbol
+            if hash.key?(key)
+              hash[key]
+            else
+              (hash.key?(key.to_s) ? hash[key.to_s] : default)
+            end
           else
-            default
+            if hash.key?(key.to_s)
+              hash[key.to_s]
+            else
+              (hash.key?(key.to_sym) ? hash[key.to_sym] : default)
+            end
           end
         end
 
@@ -183,7 +196,7 @@ module Lutaml
         end
 
         def add_singleton_method_if_not_defined(instance, method_name, &)
-          return if instance.respond_to?(method_name)
+          return if instance.singleton_class.method_defined?(method_name, false)
 
           instance.define_singleton_method(method_name, &)
         end

data/lib/lutaml/model/validation_framework.rb

@@ -38,7 +38,7 @@ module Lutaml
             next unless rule.applicable?(context)
 
             issues = rule.check(context)
-            if context.respond_to?(:add_error)
+            if context.is_a?(Validation::Context)
               issues.each { |i| context.add_error(i) }
             end
             all_issues.concat(issues)

data/lib/lutaml/model/value_transformer.rb

@@ -10,11 +10,11 @@ module Lutaml
       end
 
       def self.from(value, format)
-        new.send(:"from_#{format}", value)
+        new.public_send(:"from_#{format}", value)
       end
 
       def self.to(value, format)
-        new(value).send(:"to_#{format}")
+        new(value).public_send(:"to_#{format}")
       end
 
       def self.can_transform?(method, format)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.9"
+    VERSION = "0.8.10"
   end
 end

data/lib/lutaml/xml/adapter/adapter_helpers.rb

@@ -90,7 +90,7 @@ module Lutaml
         # @param node [Moxml::Node] The XML node
         # @return [String] The namespaced name (e.g., "uri:name" or "name")
         def namespaced_name_of(node)
-          return name_of(node) unless node.respond_to?(:namespace)
+          return name_of(node) unless node.is_a?(Lutaml::Xml::XmlElement)
 
           [node&.namespace&.uri, node.name].compact.join(":")
         end

data/lib/lutaml/xml/adapter/base_adapter.rb

@@ -126,7 +126,7 @@ module Lutaml
         # @param options [Hash] serialization options
         # @return [Boolean] true if element has ordered content
         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)
@@ -156,7 +156,7 @@ 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]
@@ -168,12 +168,12 @@ module Lutaml
         # @param rule [MappingRule] the mapping rule
         # @return [Object, nil] the attribute value or nil if delegate is nil
         def attribute_value_for(element, rule)
-          return element.send(rule.to) unless rule.delegate
+          return element.public_send(rule.to) unless rule.delegate
 
-          delegate_obj = element.send(rule.delegate)
+          delegate_obj = element.public_send(rule.delegate)
           return nil if delegate_obj.nil?
 
-          delegate_obj.send(rule.to)
+          delegate_obj.public_send(rule.to)
         end
 
         # Process content mapping for an element
@@ -186,7 +186,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,
@@ -225,15 +225,11 @@ module Lutaml
         private
 
         def attribute_values(element, &)
-          if element.respond_to?(:attributes_each_value)
-            element.attributes_each_value(&)
-          else
-            element.attributes.each_value(&)
-          end
+          element.attributes.each_value(&)
         end
 
         def schema_location_attribute?(attr)
-          attr_name = if attr.respond_to?(:unprefixed_name)
+          attr_name = if attr.is_a?(Lutaml::Xml::XmlAttribute)
                         attr.unprefixed_name
                       else
                         attr.name
@@ -242,7 +238,7 @@ module Lutaml
         end
 
         def attribute_namespace_prefix(attr)
-          if attr.respond_to?(:namespace_prefix)
+          if attr.is_a?(Lutaml::Xml::XmlAttribute)
             attr.namespace_prefix
           else
             attr.namespace&.prefix
@@ -250,7 +246,7 @@ module Lutaml
         end
 
         def attribute_hash_name(attr)
-          if attr.respond_to?(:namespaced_name)
+          if attr.is_a?(Lutaml::Xml::XmlAttribute)
             attr.namespaced_name
           else
             self.class.namespaced_attr_name(attr)

data/lib/lutaml/xml/adapter/namespace_uri_collector.rb

@@ -29,7 +29,7 @@ module Lutaml
 
           visited.add(model.object_id)
 
-          if model.respond_to?(:original_namespace_uri) && model.original_namespace_uri
+          if model.is_a?(::Lutaml::Model::Serialize) && model.class.attributes.key?(:original_namespace_uri) && model.original_namespace_uri
             original_uri = model.original_namespace_uri
             if original_uri && !original_uri.empty?
               ns_class = model.class.mappings_for(:xml)&.namespace_class
@@ -47,12 +47,12 @@ module Lutaml
             next unless attr_def
 
             child_type = attr_def.type(Lutaml::Model::Config.default_register)
-            next unless child_type.respond_to?(:<) && child_type < ::Lutaml::Model::Serializable
+            next unless child_type.is_a?(Class) && child_type < ::Lutaml::Model::Serializable
 
             child_mapping = child_type.mappings_for(:xml)
             next unless child_mapping
 
-            child_instance = model.public_send(elem_rule.to) if model.respond_to?(elem_rule.to)
+            child_instance = model.public_send(elem_rule.to) if model.class.attributes.key?(elem_rule.to)
 
             if child_instance.is_a?(Array) || child_instance.is_a?(::Lutaml::Model::Collection)
               instances = child_instance.is_a?(::Lutaml::Model::Collection) ? child_instance.collection : child_instance

data/lib/lutaml/xml/adapter/plan_based_builder.rb

@@ -158,8 +158,8 @@ module Lutaml
                                                prefix: prefix) do |inner_xml|
             # Call attribute custom methods now that element is created
             attribute_custom_methods.each do |attribute_rule|
-              mapper_class.new.send(attribute_rule.custom_methods[:to],
-                                    element, inner_xml.parent, inner_xml)
+              mapper_class.new.public_send(attribute_rule.custom_methods[:to],
+                                           element, inner_xml.parent, inner_xml)
             end
 
             if ordered?(element, options.merge(mapper_class: mapper_class))
@@ -292,7 +292,7 @@ module Lutaml
           end
 
           # Check if element was created from nil value with render_nil option
-          if element.respond_to?(:xsi_nil) && element.xsi_nil
+          if element.is_a?(Lutaml::Xml::DataModel::XmlElement) && element.xsi_nil
             attributes["xsi:nil"] = true
           end
 
@@ -301,7 +301,7 @@ module Lutaml
                                                prefix: prefix) do |inner_xml|
             # Handle raw content (map_all directive)
             has_raw_content = false
-            if element.respond_to?(:raw_content)
+            if element.is_a?(Lutaml::Xml::DataModel::XmlElement)
               raw_content = element.raw_content
               if raw_content && !raw_content.to_s.empty?
                 inner_xml.add_xml_fragment(inner_xml, raw_content.to_s)
@@ -361,8 +361,8 @@ module Lutaml
 
             # Handle custom methods
             if element_rule.custom_methods[:to]
-              mapper_class.new.send(element_rule.custom_methods[:to], element,
-                                    xml.parent, xml)
+              mapper_class.new.public_send(element_rule.custom_methods[:to], element,
+                                           xml.parent, xml)
               next
             end
 
@@ -432,8 +432,8 @@ module Lutaml
 
             # Handle custom methods
             if element_rule.custom_methods[:to]
-              mapper_class.new.send(element_rule.custom_methods[:to], element,
-                                    xml.parent, xml)
+              mapper_class.new.public_send(element_rule.custom_methods[:to], element,
+                                           xml.parent, xml)
               next
             end
 
@@ -468,7 +468,7 @@ module Lutaml
                 attribute_def = mapper_class.attributes[element_rule.to]
                 next unless attribute_def
 
-                value = element.send(element_rule.to)
+                value = element.public_send(element_rule.to)
                 next unless element_rule.render?(value, element)
 
                 # For type-only models, children plans may not be available
@@ -500,7 +500,7 @@ module Lutaml
               attribute_def = mapper_class.attributes[element_rule.to]
               next unless attribute_def
 
-              value = element.send(element_rule.to)
+              value = element.public_send(element_rule.to)
               next unless element_rule.render?(value, element)
 
               child_plan = plan.child_plan(element_rule.to)
@@ -805,10 +805,10 @@ module Lutaml
           value = nil
 
           if element_rule.delegate
-            delegate_obj = element.send(element_rule.delegate)
-            if delegate_obj.respond_to?(element_rule.to)
+            delegate_obj = element.public_send(element_rule.delegate)
+            if delegate_obj.is_a?(Lutaml::Model::Serialize) && delegate_obj.class.attributes.key?(element_rule.to)
               attribute_def = delegate_obj.class.attributes[element_rule.to]
-              value = delegate_obj.send(element_rule.to)
+              value = delegate_obj.public_send(element_rule.to)
             end
           else
             attribute_def = attribute_definition_for(element, element_rule,
@@ -828,7 +828,7 @@ module Lutaml
         # @param content [Array] accumulated content strings
         def process_ordered_content(element, xml_mapping, xml, curr_index,
 content)
-          text = element.send(xml_mapping.content_mapping.to)
+          text = element.public_send(xml_mapping.content_mapping.to)
           text = text[curr_index] if text.is_a?(Array)
 
           if element.mixed?

data/lib/lutaml/xml/adapter/xml_serializer.rb

@@ -83,7 +83,7 @@ module Lutaml
         def build_xml_element_with_plan(builder, xml_element, plan,
     options = {})
           # Add processing instructions before the root element
-          if xml_element.respond_to?(:processing_instructions)
+          if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
             xml_element.processing_instructions.each do |pi|
               builder.add_processing_instruction(pi.target, pi.content)
             end
@@ -230,7 +230,7 @@ module Lutaml
             attributes[attr_node.qualified_name] = xml_attr.value.to_s
           end
 
-          if xml_element.respond_to?(:xsi_nil) && xml_element.xsi_nil
+          if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement) && xml_element.xsi_nil
             attributes["xsi:nil"] = "true"
           end
 
@@ -240,7 +240,7 @@ module Lutaml
           attributes["xmlns"] = "" if needs_xmlns_blank
 
           xml.create_and_add_element(qualified_name, attributes: attributes) do
-            if xml_element.respond_to?(:raw_content)
+            if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
               raw_content = xml_element.raw_content
               if raw_content && !raw_content.to_s.empty?
                 xml.add_xml_fragment(xml, raw_content.to_s)

data/lib/lutaml/xml/configurable.rb

@@ -119,7 +119,8 @@ module Lutaml
         # @return [void]
         def inherit_mapping_from(mapping_class)
           # Get the parent mapping instance that has DSL already evaluated
-          parent_mapping = if mapping_class.respond_to?(:xml_mapping_instance) &&
+          parent_mapping = if mapping_class.is_a?(Class) &&
+              (mapping_class < Lutaml::Xml::Mapping || mapping_class.include?(Lutaml::Model::Serialize)) &&
               mapping_class.xml_mapping_instance
                              mapping_class.xml_mapping_instance
                            else

data/lib/lutaml/xml/data_model.rb

@@ -133,7 +133,7 @@ module Lutaml
         def qualified_name(prefix = nil)
           if prefix
             "#{prefix}:#{name}"
-          elsif namespace_class.respond_to?(:prefix_default)
+          elsif namespace_class.is_a?(Class) && namespace_class < Lutaml::Xml::Namespace
             ns_prefix = namespace_class.prefix_default
             ns_prefix ? "#{ns_prefix}:#{name}" : name
           else
@@ -202,7 +202,7 @@ module Lutaml
         def qualified_name(prefix = nil)
           if prefix
             "#{prefix}:#{name}"
-          elsif namespace_class.respond_to?(:prefix_default)
+          elsif namespace_class.is_a?(Class) && namespace_class < Lutaml::Xml::Namespace
             ns_prefix = namespace_class.prefix_default
             ns_prefix ? "#{ns_prefix}:#{name}" : name
           else

data/lib/lutaml/xml/decisions/decision_context.rb

@@ -129,7 +129,7 @@ module Lutaml
           return nil unless @element
 
           if @element.is_a?(Lutaml::Xml::XmlElement)
-            @element.namespace_prefix if @element.respond_to?(:namespace_prefix)
+            @element.namespace_prefix
           else
             # For DataModel::XmlElement, check xml_namespace_prefix first
             prefix = @element.xml_namespace_prefix
@@ -137,7 +137,7 @@ module Lutaml
 
             # Fall back to original XmlElement wrapper if available
             original = @element.original_xml_element
-            if original.respond_to?(:namespace_prefix)
+            if original.is_a?(Lutaml::Xml::XmlElement)
               return original.namespace_prefix
             end
 
@@ -213,7 +213,7 @@ module Lutaml
 
         # Returns all URIs for the current namespace (canonical + aliases).
         def namespace_all_uris
-          if @namespace_class.respond_to?(:all_uris)
+          if @namespace_class.is_a?(Class) && @namespace_class < Lutaml::Xml::Namespace
             @namespace_class.all_uris
           else
             [@namespace_uri]

data/lib/lutaml/xml/decisions/rules/element_form_default_unqualified_rule.rb

@@ -51,7 +51,7 @@ module Lutaml
 
             # Only apply if no explicit form option on the element
             # ElementFormOptionRule (Priority -0.5) handles explicit form options
-            return false if context.element.respond_to?(:form) && !context.element.form.nil?
+            return false if context.element.is_a?(Lutaml::Xml::DataModel::XmlElement) && !context.element.form.nil?
 
             true
           end

data/lib/lutaml/xml/decisions/rules/element_form_option_rule.rb

@@ -30,7 +30,7 @@ module Lutaml
           def applies?(context)
             return false unless context.element
             # Check if element responds to :form before accessing it
-            return false unless context.element.respond_to?(:form)
+            return false unless context.element.is_a?(Lutaml::Xml::DataModel::XmlElement)
 
             # Check if element has form attribute
             form = context.element.form

data/lib/lutaml/xml/decisions/rules/used_prefix_rule.rb

@@ -44,7 +44,7 @@ module Lutaml
             # Skip if namespace does NOT have element_form_default :qualified
             # Namespaces without explicit :qualified should use default format
             # (e.g., dcterms namespace uses default format, not prefix)
-            return false unless ns_class.respond_to?(:element_form_default_set?) &&
+            return false unless ns_class.is_a?(Class) && ns_class < Lutaml::Xml::Namespace &&
               ns_class.element_form_default_set? &&
               ns_class.element_form_default == :qualified
 

data/lib/lutaml/xml/declaration_plan.rb

@@ -441,7 +441,7 @@ module Lutaml
         ns_classes = []
         collect_ns_classes_recursive(@root_node, ns_classes)
         ns_classes.uniq.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
       end
 
@@ -452,7 +452,7 @@ module Lutaml
       # @return [void]
       def collect_ns_classes_recursive(element_node, ns_classes)
         # Add namespace from element's own namespace_class
-        if element_node.respond_to?(:qualified_name) && @namespace_classes
+        if element_node.is_a?(Lutaml::Xml::DeclarationPlan::ElementNode) && @namespace_classes
           # Try to find namespace class from namespace_classes by matching URI
           # The ElementNode itself doesn't store ns_class, but we can check if
           # any of our namespace_classes match the element's context