lutaml-model 0.3.1 → 0.3.3

data/lib/lutaml/model/xml_adapter/ox_adapter.rb

@@ -1,11 +1,10 @@
-# lib/lutaml/model/xml_adapter/ox_adapter.rb
 require "ox"
-require_relative "../xml_adapter"
+require_relative "xml_document"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class OxDocument < Document
+      class OxAdapter < XmlDocument
         def self.parse(xml)
           parsed = Ox.parse(xml)
           root = OxElement.new(parsed)
@@ -37,12 +36,13 @@ module Lutaml
 
           attributes = build_attributes(element, xml_mapping).compact
 
+          tag_name = options[:tag_name] || xml_mapping.root_element
           prefixed_name = if options.key?(:namespace_prefix)
-                            [options[:namespace_prefix], xml_mapping.root_element].compact.join(":")
+                            [options[:namespace_prefix], tag_name].compact.join(":")
                           elsif xml_mapping.namespace_prefix
-                            "#{xml_mapping.namespace_prefix}:#{xml_mapping.root_element}"
+                            "#{xml_mapping.namespace_prefix}:#{tag_name}"
                           else
-                            xml_mapping.root_element
+                            tag_name
                           end
 
           builder.element(prefixed_name, attributes) do |el|
@@ -85,7 +85,8 @@ module Lutaml
 
           attributes = build_attributes(element, xml_mapping).compact
 
-          builder.element(xml_mapping.root_element, attributes) do |el|
+          tag_name = options[:tag_name] || xml_mapping.root_element
+          builder.element(tag_name, attributes) do |el|
             index_hash = {}
 
             element.element_order.each do |name|
@@ -137,16 +138,16 @@ module Lutaml
         end
       end
 
-      class OxElement < Element
+      class OxElement < XmlElement
         def initialize(node, root_node: nil)
           if node.is_a?(String)
             super("text", {}, [], node, parent_document: root_node)
           else
             namespace_attributes(node.attributes).each do |(name, value)|
               if root_node
-                root_node.add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
+                root_node.add_namespace(XmlNamespace.new(value, name))
               else
-                add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
+                add_namespace(XmlNamespace.new(value, name))
               end
             end
 
@@ -156,11 +157,11 @@ module Lutaml
               namespace_prefix = name.to_s.split(":").first
               if (n = name.to_s.split(":")).length > 1
                 namespace = (root_node || self).namespaces[namespace_prefix]&.uri
-                namespace ||= Lutaml::Model::XmlAdapter::XML_NAMESPACE_URI
+                namespace ||= XML_NAMESPACE_URI
                 prefix = n.first
               end
 
-              hash[name.to_s] = Attribute.new(
+              hash[name.to_s] = XmlAttribute.new(
                 name.to_s,
                 value,
                 namespace: namespace,
@@ -173,7 +174,7 @@ module Lutaml
               attributes,
               parse_children(node, root_node: root_node || self),
               node.text,
-              parent_document: root_node
+              parent_document: root_node,
             )
           end
         end

data/lib/lutaml/model/xml_adapter/xml_attribute.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      # Represents an XML attribute
+      class XmlAttribute
+        attr_reader :name, :value, :namespace, :namespace_prefix
+
+        def initialize(name, value, namespace: nil, namespace_prefix: nil)
+          @name = name
+          @value = value
+          @namespace = namespace
+          @namespace_prefix = namespace_prefix
+        end
+
+        def unprefixed_name
+          if namespace_prefix
+            name.split(":").last
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter/xml_document.rb

@@ -0,0 +1,185 @@
+require_relative "../mapping_hash"
+require_relative "xml_element"
+require_relative "xml_attribute"
+require_relative "xml_namespace"
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class XmlDocument
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def self.parse(xml)
+          raise NotImplementedError, "Subclasses must implement `parse`."
+        end
+
+        def children
+          @root.children
+        end
+
+        def declaration(options)
+          version = "1.0"
+          version = options[:declaration] if options[:declaration].is_a?(String)
+
+          encoding = options[:encoding] ? "UTF-8" : nil
+          encoding = options[:encoding] if options[:encoding].is_a?(String)
+
+          declaration = "<?xml version=\"#{version}\""
+          declaration += " encoding=\"#{encoding}\"" if encoding
+          declaration += "?>\n"
+          declaration
+        end
+
+        def to_h
+          parse_element(@root)
+        end
+
+        def order
+          @root.order
+        end
+
+        def handle_nested_elements(builder, value, rule: nil, attribute: nil)
+          options = build_options_for_nested_elements(attribute, rule)
+
+          case value
+          when Array
+            value.each { |val| build_element(builder, val, options) }
+          else
+            build_element(builder, value, options)
+          end
+        end
+
+        def build_options_for_nested_elements(attribute, rule)
+          return {} unless rule
+
+          options = {}
+
+          options[:namespace_prefix] = rule.prefix if rule&.namespace_set?
+          options[:mixed_content] = rule.mixed_content
+          options[:tag_name] = rule.name
+
+          options[:mapper_class] = attribute&.type if attribute
+
+          options
+        end
+
+        def parse_element(element)
+          result = Lutaml::Model::MappingHash.new
+          result.item_order = element.order
+
+          element.children.each_with_object(result) do |child, hash|
+            value = child.text? ? child.text : parse_element(child)
+
+            if hash[child.unprefixed_name]
+              hash[child.unprefixed_name] =
+                [hash[child.unprefixed_name], value].flatten
+            else
+              hash[child.unprefixed_name] = value
+            end
+          end
+
+          element.attributes.each_value do |attr|
+            result[attr.unprefixed_name] = attr.value
+          end
+
+          result
+        end
+
+        def build_element(xml, element, options = {})
+          if ordered?(element, options)
+            build_ordered_element(xml, element, options)
+          else
+            build_unordered_element(xml, element, options)
+          end
+        end
+
+        def ordered?(element, options = {})
+          return false unless element.respond_to?(:element_order)
+          return element.ordered? if element.respond_to?(:ordered?)
+          return options[:mixed_content] if options.key?(:mixed_content)
+
+          mapper_class = options[:mapper_class]
+          mapper_class ? mapper_class.mappings_for(:xml).mixed_content? : false
+        end
+
+        def build_namespace_attributes(klass, processed = {})
+          xml_mappings = klass.mappings_for(:xml)
+          attributes = klass.attributes
+
+          attrs = {}
+
+          if xml_mappings.namespace_prefix
+            attrs["xmlns:#{xml_mappings.namespace_prefix}"] =
+              xml_mappings.namespace_uri
+          end
+
+          xml_mappings.mappings.each do |mapping_rule|
+            processed[klass] ||= {}
+
+            next if processed[klass][mapping_rule.name]
+
+            processed[klass][mapping_rule.name] = true
+
+            type = if mapping_rule.delegate
+                     attributes[mapping_rule.delegate].type.attributes[mapping_rule.to].type
+                   else
+                     attributes[mapping_rule.to].type
+                   end
+
+            if type <= Lutaml::Model::Serialize
+              attrs = attrs.merge(build_namespace_attributes(type, processed))
+            end
+
+            if mapping_rule.namespace
+              attrs["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
+            end
+          end
+
+          attrs
+        end
+
+        def build_attributes(element, xml_mapping)
+          attrs = namespace_attributes(xml_mapping)
+
+          xml_mapping.attributes.each_with_object(attrs) do |mapping_rule, hash|
+            if mapping_rule.namespace
+              hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
+            end
+
+            hash[mapping_rule.prefixed_name] = element.send(mapping_rule.to)
+          end
+
+          xml_mapping.elements.each_with_object(attrs) do |mapping_rule, hash|
+            if mapping_rule.namespace
+              hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
+            end
+          end
+        end
+
+        def attribute_definition_for(element, rule, mapper_class: nil)
+          klass = mapper_class || element.class
+          return klass.attributes[rule.to] unless rule.delegate
+
+          element.send(rule.delegate).class.attributes[rule.to]
+        end
+
+        def attribute_value_for(element, rule)
+          return element.send(rule.to) unless rule.delegate
+
+          element.send(rule.delegate).send(rule.to)
+        end
+
+        def namespace_attributes(xml_mapping)
+          return {} unless xml_mapping.namespace_uri
+
+          key = ["xmlns", xml_mapping.namespace_prefix].compact.join(":")
+          { key => xml_mapping.namespace_uri }
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter/xml_element.rb

@@ -0,0 +1,94 @@
+require_relative "xml_attribute"
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class XmlElement
+        attr_reader :attributes,
+                    :children,
+                    :text,
+                    :namespace_prefix,
+                    :parent_document
+
+        def initialize(
+          name,
+          attributes = {},
+          children = [],
+          text = nil,
+          parent_document: nil,
+          namespace_prefix: nil
+        )
+          @name = extract_name(name)
+          @namespace_prefix = namespace_prefix || extract_namespace_prefix(name)
+          @attributes = attributes # .map { |k, v| XmlAttribute.new(k, v) }
+          @children = children
+          @text = text
+          @parent_document = parent_document
+        end
+
+        def name
+          if namespace_prefix
+            "#{namespace_prefix}:#{@name}"
+          else
+            @name
+          end
+        end
+
+        def unprefixed_name
+          @name
+        end
+
+        def document
+          XmlDocument.new(self)
+        end
+
+        def namespaces
+          @namespaces || @parent_document&.namespaces || {}
+        end
+
+        def own_namespaces
+          @namespaces || {}
+        end
+
+        def namespace
+          return default_namespace unless namespace_prefix
+
+          namespaces[namespace_prefix]
+        end
+
+        def attribute_is_namespace?(name)
+          name.to_s.start_with?("xmlns")
+        end
+
+        def add_namespace(namespace)
+          @namespaces ||= {}
+          @namespaces[namespace.prefix] = namespace
+        end
+
+        def default_namespace
+          namespaces[nil] || @parent_document&.namespaces&.dig(nil)
+        end
+
+        def extract_name(name)
+          n = name.to_s.split(":")
+          return name if n.length <= 1
+
+          n[1..].join(":")
+        end
+
+        def extract_namespace_prefix(name)
+          n = name.to_s.split(":")
+          return if n.length <= 1
+
+          n.first
+        end
+
+        def order
+          children.each_with_object([]) do |child, arr|
+            arr << child.unprefixed_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter/xml_namespace.rb

@@ -0,0 +1,49 @@
+# frozen_striing_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      class XmlNamespace
+        # Return name
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_accessor :uri
+
+        # Return prefix
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_accessor :prefix
+
+        # Initialize instance
+        #
+        # @param [String, nil] name
+        # @param [String, nil] prefix
+        #
+        # @api private
+        def initialize(uri = nil, prefix = nil)
+          @uri = uri
+          @prefix = normalize_prefix(prefix)
+        end
+
+        def normalize_prefix(prefix)
+          normalized_prefix = prefix.to_s.gsub(/xmlns:?/, "")
+          return if normalized_prefix.empty?
+
+          normalized_prefix
+        end
+
+        def attr_name
+          if prefix && !prefix.empty?
+            "xmlns:#{prefix}"
+          else
+            "xmlns"
+          end
+        end
+      end
+    end
+  end
+end