lutaml-model 0.8.5 → 0.8.6

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

@@ -2,7 +2,12 @@
 
 require_relative "../document"
 require_relative "../declaration_handler"
+require_relative "../doctype_extractor"
 require_relative "../polymorphic_value_handler"
+require_relative "xml_parser"
+require_relative "xml_serializer"
+require_relative "plan_based_builder"
+require_relative "namespace_uri_collector"
 
 module Lutaml
   module Xml
@@ -14,56 +19,26 @@ module Lutaml
       # consistent behavior across adapters.
       #
       # Subclasses must implement:
-      # - self.parse(xml, options) - Parse XML string to document
-      # - to_xml(options) - Serialize document to XML string
+      # - MOXML_ADAPTER - Moxml adapter implementation for parsing
+      # - BUILDER_CLASS - Builder implementation for serialization
+      # - PARSED_ELEMENT_CLASS - Adapter element class returned by parsing
       #
       # @abstract Subclass and implement required methods
       class BaseAdapter < Document
+        extend DocTypeExtractor
+        extend AdapterHelpers
+        extend XmlParser
         include DeclarationHandler
         include PolymorphicValueHandler
+        include NamespaceUriCollector
+        include XmlSerializer
+        include PlanBasedBuilder
 
-        # Class methods for element inspection
-        # These are shared across all adapters
-
-        # Get the local name of an element
-        #
-        # @param element [Object] the element to inspect
-        # @return [String] the element's local name
-        def self.name_of(element)
-          element.name
-        end
-
-        # Get the prefixed name of an element
-        #
-        # @param node [Object] the element node
-        # @return [String] the prefixed name (prefix:localname)
-        def self.prefixed_name_of(node)
-          node.prefixed_name
-        end
-
-        # Get the text content of an element
-        #
-        # @param element [Object] the element to get text from
-        # @return [String] the text content
-        def self.text_of(element)
-          element.text
-        end
-
-        # Get the namespaced name of an element
-        #
-        # @param element [Object] the element to inspect
-        # @return [String] the namespaced name
-        def self.namespaced_name_of(element)
-          element.namespaced_name
-        end
-
-        # Get the order of child elements
-        #
-        # @param element [Object] the parent element
-        # @return [Array] ordered list of children
-        def self.order_of(element)
-          element.order
-        end
+        EMPTY_DOCUMENT_ERROR_MESSAGE = "Document has no root element. " \
+                                       "The XML may be empty, contain only whitespace, " \
+                                       "or consist only of an XML declaration."
+        EMPTY_DOCUMENT_ERROR_TYPE = :invalid_format
+        PARSE_ERROR_CLASS = nil
 
         # Convert a Formal Public Identifier (FPI) to a URN per RFC 3151.
         # FPI examples: "-//OASIS//DTD XML Exchange Table Model 19990315//EN"
@@ -86,11 +61,6 @@ module Lutaml
           uri.is_a?(String) && uri.start_with?("-//", "+//")
         end
 
-        # Extract processing instructions from a moxml document that appear
-        # before the root element.
-        #
-        # @param moxml_doc [Moxml::Document] the parsed document
-        # @return [Array<Lutaml::Xml::DataModel::XmlProcessingInstruction>]
         def self.extract_document_processing_instructions(moxml_doc)
           pis = []
           root = moxml_doc.root
@@ -105,15 +75,6 @@ module Lutaml
           pis
         end
 
-        # Build a namespaced attribute name
-        #
-        # @param prefix [String, nil] the namespace prefix
-        # @param name [String] the attribute name
-        # @return [String] the qualified attribute name
-        def self.namespaced_attr_name(prefix, name)
-          prefix ? "#{prefix}:#{name}" : name
-        end
-
         # Build a namespaced element name
         #
         # @param namespace_uri [String, nil] the namespace URI
@@ -142,6 +103,8 @@ module Lutaml
             options[:encoding]
           elsif options.key?(:parse_encoding)
             options[:parse_encoding]
+          elsif @encoding && @encoding.to_s.upcase != "ASCII-8BIT"
+            @encoding
           else
             "UTF-8"
           end
@@ -179,6 +142,10 @@ module Lutaml
           false
         end
 
+        def order
+          root.order
+        end
+
         # Get attribute definition for an element and rule
         #
         # @param element [Object] the model instance
@@ -240,430 +207,53 @@ module Lutaml
         def attributes_hash(element)
           result = Lutaml::Model::MappingHash.new
 
-          element.attributes.each_value do |attr|
-            if attr.unprefixed_name == "schemaLocation"
+          attribute_values(element) do |attr|
+            if schema_location_attribute?(attr)
               result["__schema_location"] = {
                 namespace: attr.namespace,
-                prefix: attr.namespace_prefix,
+                prefix: attribute_namespace_prefix(attr),
                 schema_location: attr.value,
               }
             else
-              result[attr.namespaced_name] = attr.value
+              result[attribute_hash_name(attr)] = attr.value
             end
           end
 
           result
         end
 
-        # Add text content to XML builder
-        #
-        # @param xml [Builder] the XML builder
-        # @param value [Object] the value to add
-        # @param attribute [Attribute, nil] the attribute definition
-        # @param cdata [Boolean] whether to use CDATA
-        def add_value(xml, value, attribute, cdata: false)
-          if !value.nil?
-            if attribute.nil?
-              # For delegated attributes where attribute is nil, just use the raw value
-              xml.add_text(xml, value.to_s, cdata: cdata)
-            elsif attribute.transform.is_a?(Class) && attribute.transform < Lutaml::Model::ValueTransformer
-              # Value has already been transformed, use it directly
-              xml.add_text(xml, value.to_s, cdata: cdata)
-            else
-              # Normal serialization through attribute type system
-              serialized_value = attribute.serialize(value, :xml, register)
-              if attribute.raw?
-                xml.add_xml_fragment(xml, value)
-              elsif serialized_value.is_a?(Hash)
-                serialized_value.each do |key, val|
-                  xml.create_and_add_element(key) do |element|
-                    element.text(val)
-                  end
-                end
-              else
-                xml.add_text(xml, serialized_value, cdata: cdata)
-              end
-            end
-          end
-        end
-
-        # Get child plan from parent plan (unified access for both object and hash plans)
-        #
-        # @param plan [DeclarationPlan, Hash, nil] the parent plan
-        # @param attr_name [Symbol] the attribute name
-        # @return [DeclarationPlan, Hash, nil] the child plan or nil
-        def child_plan_for(plan, attr_name)
-          return nil unless plan
-
-          if plan.respond_to?(:child_plan)
-            # DeclarationPlan object (Nokogiri/Oga)
-            plan.child_plan(attr_name)
-          elsif plan.respond_to?(:[])
-            # Hash-based plan (Ox/REXML)
-            plan[:children_plans]&.[](attr_name)
-          end
-        end
-
-        # Build unordered child elements using prepared namespace declaration plan
-        #
-        # This is the shared implementation for all adapters. Adapters may override
-        # if they need custom behavior.
-        #
-        # @param xml [Builder] the XML builder
-        # @param element [Object] the model instance
-        # @param plan [DeclarationPlan, Hash] the declaration plan
-        # @param options [Hash] serialization options
-        def build_unordered_children_with_plan(xml, element, plan, options)
-          mapper_class = options[:mapper_class] || element.class
-          xml_mapping = mapper_class.mappings_for(:xml)
-
-          # Process child elements with their plans (INCLUDING raw_mapping for map all)
-          mappings = xml_mapping.elements + [xml_mapping.raw_mapping].compact
-          mappings.each do |element_rule|
-            next if options[:except]&.include?(element_rule.to)
-
-            # Handle custom methods
-            if element_rule.custom_methods[:to]
-              mapper_class.new.send(element_rule.custom_methods[:to], element,
-                                    xml.parent, xml)
-              next
-            end
-
-            attribute_def = attribute_definition_for(element, element_rule,
-                                                     mapper_class: mapper_class)
-
-            # For delegated attributes, attribute_def might be nil
-            next unless attribute_def || element_rule.delegate
-
-            value = attribute_value_for(element, element_rule)
-            next unless element_rule.render?(value, element)
-
-            # Get child's plan if available
-            child_plan = child_plan_for(plan, element_rule.to)
-
-            # Check if value is a Collection instance
-            is_collection_instance = value.is_a?(Lutaml::Model::Collection)
-
-            if value && (attribute_def&.type(register)&.<=(Lutaml::Model::Serialize) || is_collection_instance)
-              handle_nested_elements_with_plan(
-                xml,
-                value,
-                element_rule,
-                attribute_def,
-                child_plan,
-                options,
-                parent_plan: plan,
-              )
-            elsif element_rule.delegate && attribute_def.nil?
-              # Handle non-model values (strings, etc.) for delegated attributes
-              add_simple_value(xml, element_rule, value, nil, plan: plan,
-                                                              mapping: xml_mapping, options: options)
-            else
-              add_simple_value(xml, element_rule, value, attribute_def,
-                               plan: plan, mapping: xml_mapping, options: options)
-            end
-          end
-
-          # Process content mapping
-          process_content_mapping(element, xml_mapping.content_mapping,
-                                  xml, mapper_class)
-        end
-
-        # Build ordered child elements using prepared namespace declaration plan
-        #
-        # This is the shared implementation for all adapters. Adapters may override
-        # if they need custom behavior.
-        #
-        # @param xml [Builder] the XML builder
-        # @param element [Object] the model instance
-        # @param plan [DeclarationPlan, Hash] the declaration plan
-        # @param options [Hash] serialization options
-        def build_ordered_element_with_plan(xml, element, plan, options)
-          mapper_class = options[:mapper_class] || element.class
-          xml_mapping = mapper_class.mappings_for(:xml)
-
-          index_hash = {}
-          content = []
-
-          element.element_order.each do |object|
-            object_key = "#{object.name}-#{object.type}"
-            index_hash[object_key] ||= -1
-            curr_index = index_hash[object_key] += 1
-
-            element_rule = xml_mapping.find_by_name(object.name,
-                                                    type: object.type,
-                                                    node_type: object.node_type,
-                                                    namespace_uri: object.namespace_uri)
-            next if element_rule.nil? || options[:except]&.include?(element_rule.to)
-
-            # Handle custom methods
-            if element_rule.custom_methods[:to]
-              mapper_class.new.send(element_rule.custom_methods[:to], element,
-                                    xml.parent, xml)
-              next
-            end
-
-            # Get attribute definition and value (handle delegation)
-            attribute_def, value = fetch_attribute_and_value(element,
-                                                             element_rule, mapper_class)
-
-            next if element_rule == xml_mapping.content_mapping && element_rule.cdata && object.text?
-
-            if element_rule == xml_mapping.content_mapping
-              process_ordered_content(element, xml_mapping, xml, curr_index,
-                                      content)
-            elsif !value.nil? || element_rule.render_nil?
-              process_ordered_element(xml, element, element_rule, attribute_def,
-                                      value, curr_index, plan, xml_mapping, options)
-            end
-          end
-
-          add_ordered_content(xml, content) unless content.empty?
-        end
-
         private
 
-        # Add text or CDATA content to a moxml element.
-        # Nokogiri overrides add_text_nodes for entity reference preservation.
-        def add_content_node(element, text, doc, cdata: false)
-          if cdata
-            element.add_child(doc.create_cdata(text.to_s))
+        def attribute_values(element, &)
+          if element.respond_to?(:attributes_each_value)
+            element.attributes_each_value(&)
           else
-            add_text_nodes(element, text.to_s, doc)
+            element.attributes.each_value(&)
           end
         end
 
-        # Create text node(s) for element content.
-        # Default: single text node. Nokogiri overrides to split entity references.
-        def add_text_nodes(element, text, doc)
-          element.add_child(doc.create_text(text))
+        def schema_location_attribute?(attr)
+          attr_name = if attr.respond_to?(:unprefixed_name)
+                        attr.unprefixed_name
+                      else
+                        attr.name
+                      end
+          attr_name == "schemaLocation"
         end
 
-        # Apply XML attributes from XmlElement to a moxml element,
-        # filtering xmlns attributes that are already declared via hoisted_declarations.
-        def apply_plan_attributes(xml_element, element_node, element)
-          xml_element.attributes.each_with_index do |xml_attr, idx|
-            attr_name_str = xml_attr.name.to_s
-            if attr_name_str.start_with?("xmlns")
-              apply_xmlns_attribute(attr_name_str, xml_attr.value.to_s,
-                                    element_node, element)
-              next
-            end
-
-            attr_node = element_node.attribute_nodes[idx]
-            element[attr_node.qualified_name] = xml_attr.value.to_s
-          end
-        end
-
-        def apply_xmlns_attribute(attr_name_str, value, element_node, element)
-          if attr_name_str.include?(":")
-            prefix = attr_name_str.split(":", 2).last
-            unless element_node.hoisted_declarations.key?(prefix)
-              element.add_namespace(prefix, value)
-            end
-          elsif attr_name_str == "xmlns"
-            unless element_node.hoisted_declarations.key?(nil)
-              element.add_namespace(nil, value)
-            end
-          end
-        end
-
-        # Fetch attribute definition and value, handling delegation
-        #
-        # @param element [Object] the model instance
-        # @param element_rule [MappingRule] the mapping rule
-        # @param mapper_class [Class] the mapper class
-        # @return [Array<(Attribute, Object)>] attribute definition and value tuple
-        def fetch_attribute_and_value(element, element_rule, mapper_class)
-          attribute_def = nil
-          value = nil
-
-          if element_rule.delegate
-            delegate_obj = element.send(element_rule.delegate)
-            if delegate_obj.respond_to?(element_rule.to)
-              attribute_def = delegate_obj.class.attributes[element_rule.to]
-              value = delegate_obj.send(element_rule.to)
-            end
-          else
-            attribute_def = attribute_definition_for(element, element_rule,
-                                                     mapper_class: mapper_class)
-            value = attribute_value_for(element, element_rule)
-          end
-
-          [attribute_def, value]
-        end
-
-        # Process content for ordered elements
-        #
-        # @param element [Object] the model instance
-        # @param xml_mapping [Xml::Mapping] the XML mapping
-        # @param xml [Builder] the XML builder
-        # @param curr_index [Integer] current index in collection
-        # @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 = text[curr_index] if text.is_a?(Array)
-
-          if element.mixed?
-            add_mixed_text(xml, text)
+        def attribute_namespace_prefix(attr)
+          if attr.respond_to?(:namespace_prefix)
+            attr.namespace_prefix
           else
-            content << text
+            attr.namespace&.prefix
           end
         end
 
-        # Process a single ordered element
-        #
-        # @param xml [Builder] the XML builder
-        # @param element [Object] the model instance
-        # @param element_rule [MappingRule] the mapping rule
-        # @param attribute_def [Attribute, nil] the attribute definition
-        # @param value [Object] the value
-        # @param curr_index [Integer] current index in collection
-        # @param plan [DeclarationPlan, Hash] the declaration plan
-        # @param xml_mapping [Xml::Mapping] the XML mapping
-        # @param options [Hash] serialization options
-        def process_ordered_element(xml, element, element_rule, attribute_def,
-                                    value, curr_index, plan, xml_mapping, options)
-          # Handle collection values by index
-          current_value = if attribute_def&.collection? && value.is_a?(Array)
-                            value[curr_index]
-                          elsif attribute_def&.collection? && value.is_a?(Lutaml::Model::Collection)
-                            value.to_a[curr_index]
-                          else
-                            value
-                          end
-
-          # Get child's plan if available
-          child_plan = child_plan_for(plan, element_rule.to)
-
-          is_collection_instance = current_value.is_a?(Lutaml::Model::Collection)
-
-          if current_value && (attribute_def&.type(register)&.<=(Lutaml::Model::Serialize) || is_collection_instance)
-            handle_nested_elements_with_plan(
-              xml,
-              current_value,
-              element_rule,
-              attribute_def,
-              child_plan,
-              options,
-              parent_plan: plan,
-            )
+        def attribute_hash_name(attr)
+          if attr.respond_to?(:namespaced_name)
+            attr.namespaced_name
           else
-            # Apply transformations if attribute_def exists
-            if attribute_def
-              current_value = ExportTransformer.call(current_value,
-                                                     element_rule, attribute_def, format: :xml)
-            end
-
-            # For mixed content, create elements directly
-            if element.mixed? && !attribute_def&.raw?
-              add_mixed_element(xml, element_rule, current_value, attribute_def,
-                                plan: plan, mapping: xml_mapping)
-            else
-              add_simple_value(xml, element_rule, current_value,
-                               attribute_def, plan: plan, mapping: xml_mapping, options: options)
-            end
-          end
-        end
-
-        # Add text for mixed content (can be overridden by adapters)
-        #
-        # @param xml [Builder] the XML builder
-        # @param text [String] the text to add
-        def add_mixed_text(xml, text)
-          # Default implementation - adapters may override
-          xml.add_text(xml, text) unless text.nil? || text.to_s.empty?
-        end
-
-        # Add element for mixed content (can be overridden by adapters)
-        #
-        # @param xml [Builder] the XML builder
-        # @param element_rule [MappingRule] the element rule
-        # @param value [Object] the value to add
-        # @param attribute [Attribute, nil] the attribute definition
-        # @param plan [DeclarationPlan, Hash, nil] the declaration plan
-        # @param mapping [Xml::Mapping] the XML mapping
-        def add_mixed_element(xml, element_rule, value, _attribute, _plan:,
-_mapping:)
-          # Default implementation - adapters may override
-          xml.create_and_add_element(element_rule.name) do |child_element|
-            child_element.text(value.to_s) unless ::Lutaml::Model::Utils.empty?(value)
-          end
-        end
-
-        # Add accumulated content (can be overridden by adapters)
-        #
-        # @param xml [Builder] the XML builder
-        # @param content [Array<String>] accumulated content strings
-        def add_ordered_content(xml, content)
-          # Default implementation - adapters may override
-          xml.add_text(xml, content.join)
-        end
-
-        # Collect original namespace URIs from a model tree for namespace alias support.
-        #
-        # When parsing XML with alias URIs (e.g., "http://.../") against a namespace
-        # class with canonical URI (e.g., "http://.../reqif.xsd"), the original alias
-        # URI is stored on the model instance as @__xml_original_namespace_uri.
-        # This method collects all such mappings from the model tree.
-        #
-        # @param model [Object] the model instance to walk
-        # @param mapping [Xml::Mapping, nil] the mapping for the model
-        # @return [Hash<String, String>] Mapping of canonical URI => original alias URI
-        def collect_original_namespace_uris(model, mapping = nil)
-          original_uris = {}
-          return original_uris unless model
-
-          collect_from_model(model, mapping, original_uris, Set.new)
-          original_uris
-        end
-
-        # Recursively walk model tree to collect original namespace URIs
-        def collect_from_model(model, mapping, original_uris, visited)
-          return unless model.is_a?(::Lutaml::Model::Serialize)
-          return if visited.include?(model.object_id)
-
-          visited.add(model.object_id)
-
-          # Check if this model has an original namespace URI
-          if model.respond_to?(:original_namespace_uri) && model.original_namespace_uri
-            original_uri = model.original_namespace_uri
-            if original_uri && !original_uri.empty?
-              # Look up the model's namespace class
-              ns_class = model.class.mappings_for(:xml)&.namespace_class
-              if ns_class && ns_class.uri != original_uri
-                # Only store if the canonical URI differs (it's an alias)
-                original_uris[ns_class.uri] = original_uri
-              end
-            end
-          end
-
-          return unless mapping
-
-          # Recurse into child Serializable attributes
-          attributes = model.class.attributes
-          mapping.elements.each do |elem_rule|
-            attr_def = attributes[elem_rule.to]
-            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
-
-            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)
-
-            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
-              instances.each do |item|
-                collect_from_model(item, child_mapping, original_uris, visited)
-              end
-            elsif child_instance
-              collect_from_model(child_instance, child_mapping, original_uris,
-                                 visited)
-            end
+            self.class.namespaced_attr_name(attr)
           end
         end
       end

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

@@ -30,23 +30,6 @@ module Lutaml
           @prefix = normalize_prefix(prefix)
         end
 
-        # Generate unique key for this namespace configuration
-        #
-        # The key is based on prefix and URI, ensuring that same config = same key.
-        # This enables proper deduplication and lookup in hash structures.
-        #
-        # @return [String] unique key in format "prefix:uri" or ":uri" for default
-        def self.to_key
-          prefix = prefix_default
-          uri = self.uri
-
-          if prefix && !prefix.empty?
-            "#{prefix}:#{uri}"
-          else
-            ":#{uri}"
-          end
-        end
-
         def normalize_prefix(prefix)
           # Only strip "xmlns:" prefix (e.g., "xmlns:foo" → "foo").
           # Do NOT strip "xmlns" from prefixes like "xmlns_1.0" (valid NCName).

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Adapter
+      # Collects original namespace URIs from a model tree for namespace alias support.
+      #
+      # When parsing XML with alias URIs (e.g., "http://.../") against a namespace
+      # class with canonical URI (e.g., "http://.../reqif.xsd"), the original alias
+      # URI is stored on the model instance as @__xml_original_namespace_uri.
+      # This module collects all such mappings from the model tree.
+      module NamespaceUriCollector
+        # @param model [Object] the model instance to walk
+        # @param mapping [Xml::Mapping, nil] the mapping for the model
+        # @return [Hash<String, String>] Mapping of canonical URI => original alias URI
+        def collect_original_namespace_uris(model, mapping = nil)
+          original_uris = {}
+          return original_uris unless model
+
+          collect_from_model(model, mapping, original_uris, Set.new)
+          original_uris
+        end
+
+        private
+
+        def collect_from_model(model, mapping, original_uris, visited)
+          return unless model.is_a?(::Lutaml::Model::Serialize)
+          return if visited.include?(model.object_id)
+
+          visited.add(model.object_id)
+
+          if model.respond_to?(: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
+              if ns_class && ns_class.uri != original_uri
+                original_uris[ns_class.uri] = original_uri
+              end
+            end
+          end
+
+          return unless mapping
+
+          attributes = model.class.attributes
+          mapping.elements.each do |elem_rule|
+            attr_def = attributes[elem_rule.to]
+            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
+
+            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)
+
+            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
+              instances.each do |item|
+                collect_from_model(item, child_mapping, original_uris, visited)
+              end
+            elsif child_instance
+              collect_from_model(child_instance, child_mapping, original_uris,
+                                 visited)
+            end
+          end
+        end
+      end
+    end
+  end
+end