lutaml-model 0.1.0 → 0.3.0

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

@@ -12,62 +12,206 @@ module Lutaml
           new(root)
         end
 
-        def initialize(root)
-          @root = root
-        end
-
-        def to_h
-          { @root.name => parse_element(@root) }
-        end
-
         def to_xml(options = {})
           builder = Ox::Builder.new
-          build_element(builder, @root, options)
-          xml_data = Ox.dump(builder)
+          if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
+            @root.to_xml(builder)
+          elsif @root.ordered?
+            build_ordered_element(builder, @root, options)
+          else
+            build_element(builder, @root, options)
+          end
+
+          # xml_data = Ox.dump(builder)
+          xml_data = builder.to_s
           options[:declaration] ? declaration(options) + xml_data : xml_data
         end
 
         private
 
-        def build_element(builder, element, options = {})
-          attributes = build_attributes(element.attributes)
-          builder.element(element.name, attributes) do
-            element.children.each do |child|
-              build_element(builder, child, options)
+        def build_unordered_element(builder, element, options = {})
+          xml_mapping = element.class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = build_attributes(element, xml_mapping).compact
+
+          prefixed_name = if options.key?(:namespace_prefix)
+                            [options[:namespace_prefix], xml_mapping.root_element].compact.join(":")
+                          elsif xml_mapping.namespace_prefix
+                            "#{xml_mapping.namespace_prefix}:#{xml_mapping.root_element}"
+                          else
+                            xml_mapping.root_element
+                          end
+
+          builder.element(prefixed_name, attributes) do |el|
+            xml_mapping.elements.each do |element_rule|
+              attribute_def = attribute_definition_for(element, element_rule)
+              value = attribute_value_for(element, element_rule)
+
+              val = if attribute_def.collection?
+                      value
+                    elsif value || element_rule.render_nil?
+                      [value]
+                    else
+                      []
+                    end
+
+              val.each do |v|
+                if attribute_def&.type&.<= Lutaml::Model::Serialize
+                  handle_nested_elements(el, v, element_rule)
+                else
+                  builder.element(element_rule.prefixed_name) do |el|
+                    el.text(attribute_def.type.serialize(v)) if v
+                  end
+                end
+              end
+            end
+
+            if xml_mapping.content_mapping
+              text = element.send(xml_mapping.content_mapping.to)
+              text = text.join if text.is_a?(Array)
+
+              el.text text
             end
-            builder.text(element.text) if element.text
           end
         end
 
-        def build_attributes(attributes)
-          attributes.each_with_object({}) do |(name, attr), hash|
-            hash[name] = attr.value
+        def build_ordered_element(builder, element, _options = {})
+          xml_mapping = element.class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = build_attributes(element, xml_mapping).compact
+
+          builder.element(xml_mapping.root_element, attributes) do |el|
+            index_hash = {}
+
+            element.element_order.each do |name|
+              index_hash[name] ||= -1
+              curr_index = index_hash[name] += 1
+
+              element_rule = xml_mapping.find_by_name(name)
+
+              attribute_def = attribute_definition_for(element, element_rule)
+              value = attribute_value_for(element, element_rule)
+
+              if element_rule == xml_mapping.content_mapping
+                text = element.send(xml_mapping.content_mapping.to)
+                text = text[curr_index] if text.is_a?(Array)
+
+                el.text text
+              elsif attribute_def.collection?
+                add_to_xml(el, value[curr_index], attribute_def, element_rule)
+              elsif !value.nil? || element_rule.render_nil?
+                add_to_xml(el, value, attribute_def, element_rule)
+              end
+            end
           end
         end
 
-        def parse_element(element)
-          result = { "_text" => element.text }
-          element.nodes.each do |child|
-            next if child.is_a?(Ox::Raw) || child.is_a?(Ox::Comment)
-            result[child.name] ||= []
-            result[child.name] << parse_element(child)
+        def add_to_xml(xml, value, attribute, rule)
+          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+            handle_nested_elements(xml, value, rule)
+          else
+            xml.element(rule.name) do |el|
+              if !value.nil?
+                serialized_value = attribute.type.serialize(value)
+
+                if attribute.type == Lutaml::Model::Type::Hash
+                  serialized_value.each do |key, val|
+                    el.element(key) { |child_el| child_el.text val }
+                  end
+                else
+                  el.text(serialized_value)
+                end
+              end
+            end
           end
-          result
         end
       end
 
       class OxElement < Element
-        def initialize(node)
-          attributes = node.attributes.each_with_object({}) do |(name, value), hash|
-            hash[name.to_s] = Attribute.new(name.to_s, value)
+        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))
+              else
+                add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
+              end
+            end
+
+            attributes = node.attributes.each_with_object({}) do |(name, value), hash|
+              next if attribute_is_namespace?(name)
+
+              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
+                prefix = n.first
+              end
+
+              hash[name.to_s] = Attribute.new(
+                name.to_s,
+                value,
+                namespace: namespace,
+                namespace_prefix: prefix,
+              )
+            end
+
+            super(
+              node.name.to_s,
+              attributes,
+              parse_children(node, root_node: root_node || self),
+              node.text,
+              parent_document: root_node
+            )
           end
-          super(node.name.to_s, attributes, parse_children(node), node.text)
+        end
+
+        def to_xml(builder = nil)
+          builder ||= Ox::Builder.new
+          attrs = build_attributes(self)
+
+          if text?
+            builder.text(text)
+          else
+            builder.element(name, attrs) do |el|
+              children.each { |child| child.to_xml(el) }
+            end
+          end
+        end
+
+        def namespace_attributes(attributes)
+          attributes.select { |attr| attribute_is_namespace?(attr) }
+        end
+
+        def text?
+          # false
+          children.empty? && text&.length&.positive?
+        end
+
+        def build_attributes(node)
+          attrs = node.attributes.transform_values(&:value)
+
+          node.own_namespaces.each_value do |namespace|
+            attrs[namespace.attr_name] = namespace.uri
+          end
+
+          attrs
+        end
+
+        def nodes
+          children
         end
 
         private
 
-        def parse_children(node)
-          node.nodes.select { |child| child.is_a?(Ox::Element) }.map { |child| OxElement.new(child) }
+        def parse_children(node, root_node: nil)
+          node.nodes.map do |child|
+            OxElement.new(child, root_node: root_node)
+          end
         end
       end
     end

data/lib/lutaml/model/xml_adapter.rb

@@ -1,8 +1,13 @@
 # lib/lutaml/model/xml_adapter.rb
 
+require_relative "xml_namespace"
+require_relative "mapping_hash"
+
 module Lutaml
   module Model
     module XmlAdapter
+      XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace".freeze
+
       class Document
         attr_reader :root
 
@@ -19,30 +24,230 @@ module Lutaml
         end
 
         def declaration(options)
-          version = options[:declaration].is_a?(String) ? options[:declaration] : "1.0"
-          encoding = options[:encoding].is_a?(String) ? options[:encoding] : (options[:encoding] ? "UTF-8" : nil)
+          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)
+          options = {}
+
+          if rule&.namespace_set?
+            options[:namespace_prefix] = rule.prefix
+          end
+
+          case value
+          when Array
+            value.each { |val| build_element(builder, val, options) }
+          else
+            build_element(builder, value, options)
+          end
+        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 element.ordered?
+            build_ordered_element(xml, element, _options)
+          else
+            build_unordered_element(xml, element, _options)
+          end
+        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)
+          return element.class.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
 
       class Element
-        attr_reader :name, :attributes, :children, :text, :namespace, :namespace_prefix
+        attr_reader :attributes,
+                    :children,
+                    :text,
+                    :namespace_prefix,
+                    :parent_document
 
-        def initialize(name, attributes = {}, children = [], text = nil, namespace: nil, namespace_prefix: nil)
-          @name = name
-          @attributes = attributes.map { |k, v| Attribute.new(k, v) }
+        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| Attribute.new(k, v) }
           @children = children
           @text = text
-          @namespace = namespace
-          @namespace_prefix = namespace_prefix
+          @parent_document = parent_document
+        end
+
+        def name
+          if namespace_prefix
+            "#{namespace_prefix}:#{@name}"
+          else
+            @name
+          end
+        end
+
+        def unprefixed_name
+          @name
         end
 
         def document
           Document.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
 
       class Attribute
@@ -54,6 +259,14 @@ module Lutaml
           @namespace = namespace
           @namespace_prefix = namespace_prefix
         end
+
+        def unprefixed_name
+          if namespace_prefix
+            name.split(":").last
+          else
+            name
+          end
+        end
       end
     end
   end

data/lib/lutaml/model/xml_mapping.rb

@@ -4,16 +4,31 @@ require_relative "xml_mapping_rule"
 module Lutaml
   module Model
     class XmlMapping
-      attr_reader :root_element, :namespace_uri, :namespace_prefix
+      attr_reader :root_element,
+                  :namespace_uri,
+                  :namespace_prefix,
+                  :mixed_content
 
       def initialize
         @elements = []
         @attributes = []
         @content_mapping = nil
+        @mixed_content = false
       end
 
-      def root(name)
+      alias mixed_content? mixed_content
+
+      def root(name, mixed: false)
         @root_element = name
+        @mixed_content = mixed
+      end
+
+      def prefixed_root
+        if namespace_uri && namespace_prefix
+          "#{namespace_prefix}:#{root_element}"
+        else
+          root_element
+        end
       end
 
       def namespace(uri, prefix = nil)
@@ -21,16 +36,69 @@ module Lutaml
         @namespace_prefix = prefix
       end
 
-      def map_element(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
-        @elements << XmlMappingRule.new(name, to: to, render_nil: render_nil, with: with, delegate: delegate, namespace: namespace, prefix: prefix)
+      # rubocop:disable Metrics/ParameterLists
+      def map_element(
+        name,
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        namespace: (namespace_set = false
+                    nil),
+        prefix: nil,
+        mixed: false
+      )
+        @elements << XmlMappingRule.new(
+          name,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+          namespace: namespace,
+          prefix: prefix,
+          mixed_content: mixed,
+          namespace_set: namespace_set != false,
+        )
       end
 
-      def map_attribute(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
-        @attributes << XmlMappingRule.new(name, to: to, render_nil: render_nil, with: with, delegate: delegate, namespace: namespace, prefix: prefix)
+      def map_attribute(
+        name,
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        namespace: (namespace_set = false
+                    nil),
+        prefix: nil
+      )
+        @attributes << XmlMappingRule.new(
+          name,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+          namespace: namespace,
+          prefix: prefix,
+          namespace_set: namespace_set != false,
+        )
       end
+      # rubocop:enable Metrics/ParameterLists
 
-      def map_content(to:, render_nil: false, with: {}, delegate: nil)
-        @content_mapping = XmlMappingRule.new(nil, to: to, render_nil: render_nil, with: with, delegate: delegate)
+      def map_content(
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        mixed: false
+      )
+        @content_mapping = XmlMappingRule.new(
+          nil,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+          mixed_content: mixed,
+        )
       end
 
       def elements
@@ -60,6 +128,16 @@ module Lutaml
           name == rule.to
         end
       end
+
+      def find_by_name(name)
+        if name.to_s == "text"
+          content_mapping
+        else
+          mappings.detect do |rule|
+            rule.name == name.to_s || rule.name == name.to_sym
+          end
+        end
+      end
     end
   end
 end

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -6,9 +6,33 @@ module Lutaml
     class XmlMappingRule < MappingRule
       attr_reader :namespace, :prefix
 
-      def initialize(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
-        super(name, to: to, render_nil: render_nil, with: with, delegate: delegate)
-        @namespace = namespace
+      def initialize(
+        name,
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        namespace: nil,
+        prefix: nil,
+        mixed_content: false,
+        namespace_set: false
+      )
+        super(
+          name,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+          mixed_content: mixed_content,
+          namespace_set: namespace_set
+        )
+
+        @namespace = if namespace.to_s == "inherit"
+                       # we are using inherit_namespace in xml builder by
+                       # default so no need to do anything here.
+                     else
+                       namespace
+                     end
         @prefix = prefix
       end
     end