lutaml-model 0.2.1 → 0.3.1

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

@@ -12,14 +12,15 @@ module Lutaml
           new(root)
         end
 
-        def to_h
-          # { @root.name => parse_element(@root) }
-          parse_element(@root)
-        end
-
         def to_xml(options = {})
-          builder = Nokogiri::XML::Builder.new do |xml|
-            build_element(xml, @root, options)
+          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+            if root.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
+              root.to_xml(xml)
+            else
+              mapper_class = options[:mapper_class] || @root.class
+              options[:xml_attributes] = build_namespace_attributes(mapper_class)
+              build_element(xml, @root, options)
+            end
           end
 
           xml_options = {}
@@ -31,123 +32,129 @@ module Lutaml
 
         private
 
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Metrics/BlockLength
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
-        def build_element(xml, element, _options = {})
-          if element.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
-            return element.to_xml(xml)
-          end
-
-          xml_mapping = element.class.mappings_for(:xml)
+        def build_unordered_element(xml, element, options = {})
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
-          attributes = build_attributes(element, xml_mapping)
+          attributes = options[:xml_attributes] ||= {}
+          attributes = build_attributes(element,
+                                        xml_mapping).merge(attributes)&.compact
 
-          prefixed_xml = if xml_mapping.namespace_prefix
+          prefixed_xml = if options.key?(:namespace_prefix)
+                           options[:namespace_prefix] ? xml[options[:namespace_prefix]] : xml
+                         elsif xml_mapping.namespace_prefix
                            xml[xml_mapping.namespace_prefix]
                          else
                            xml
                          end
 
-          prefixed_xml.send(xml_mapping.root_element, attributes) do
+          prefixed_xml.public_send(xml_mapping.root_element, attributes) do
+            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
+              xml.parent.namespace = nil
+            end
+
             xml_mapping.elements.each do |element_rule|
-              if element_rule.delegate
-                attribute_def =
-                  element
-                    .send(element_rule.delegate)
-                    .class
-                    .attributes[element_rule.to]
-
-                value =
-                  element
-                    .send(element_rule.delegate)
-                    .send(element_rule.to)
-              else
-                attribute_def = element.class.attributes[element_rule.to]
-                value = element.send(element_rule.to)
-              end
+              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
+              value = attribute_value_for(element, element_rule)
+
+              next if value.nil? && !element_rule.render_nil?
 
               nsp_xml = element_rule.prefix ? xml[element_rule.prefix] : xml
 
-              val = if attribute_def.collection?
-                      value
-                    elsif !value.nil? || element_rule.render_nil?
-                      [value]
-                    else
-                      []
-                    end
-
-              val.each do |v|
-                if attribute_def&.type&.<= Lutaml::Model::Serialize
-                  handle_nested_elements(xml, element_rule, v)
-                else
-                  nsp_xml.send(element_rule.name) do
-                    if !v.nil?
-                      serialized_value = attribute_def.type.serialize(v)
-
-                      if attribute_def.type == Lutaml::Model::Type::Hash
-                        serialized_value.each do |key, val|
-                          xml.send(key) { xml.text val }
-                        end
-                      else
-                        xml.text(serialized_value)
-                      end
-                    end
-                  end
+              if attribute_def.collection?
+                value.each do |v|
+                  add_to_xml(nsp_xml, v, attribute_def, element_rule)
                 end
+              elsif !value.nil? || element_rule.render_nil?
+                add_to_xml(nsp_xml, value, attribute_def, element_rule)
               end
             end
-            prefixed_xml.text element.text unless xml_mapping.elements.any?
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-        # rubocop:enable Metrics/BlockLength
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/PerceivedComplexity
-
-        def handle_nested_elements(xml, _element_rule, value)
-          case value
-          when Array
-            value.each { |val| build_element(xml, val) }
-          else
-            build_element(xml, value)
+
+            if xml_mapping.content_mapping
+              text = element.send(xml_mapping.content_mapping.to)
+              text = text.join if text.is_a?(Array)
+
+              prefixed_xml.text text
+            end
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/MethodLength
-        def parse_element(element)
-          result = element.children.each_with_object({}) do |child, hash|
-            value = child.text? ? child.text : parse_element(child)
+        def build_ordered_element(xml, element, options = {})
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
+          return xml unless xml_mapping
 
-            if hash[child.unprefixed_name]
-              hash[child.unprefixed_name] =
-                [hash[child.unprefixed_name], value].flatten
-            else
-              hash[child.unprefixed_name] = value
+          attributes = build_attributes(element, xml_mapping)&.compact
+
+          prefixed_xml = if options.key?(:namespace_prefix)
+                           options[:namespace_prefix] ? xml[options[:namespace_prefix]] : xml
+                         elsif xml_mapping.namespace_prefix
+                           xml[xml_mapping.namespace_prefix]
+                         else
+                           xml
+                         end
+
+          prefixed_xml.public_send(xml_mapping.root_element, attributes) do
+            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
+              xml.parent.namespace = nil
             end
-          end
 
-          element.attributes.each do |name, attr|
-            result[name] = attr.value
+            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)
+              next if element_rule.nil?
+
+              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
+              value = attribute_value_for(element, element_rule)
+              nsp_xml = element_rule.prefix ? xml[element_rule.prefix] : xml
+
+              if element_rule == xml_mapping.content_mapping
+                text = element.send(xml_mapping.content_mapping.to)
+                text = text[curr_index] if text.is_a?(Array)
+
+                prefixed_xml.text text
+              elsif attribute_def.collection?
+                add_to_xml(nsp_xml, value[curr_index], attribute_def,
+                           element_rule)
+              elsif !value.nil? || element_rule.render_nil?
+                add_to_xml(nsp_xml, value, attribute_def, element_rule)
+              end
+            end
           end
+        end
+
+        def add_to_xml(xml, value, attribute, rule)
+          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+            handle_nested_elements(
+              xml,
+              value,
+              rule: rule,
+              attribute: attribute,
+            )
+          else
+            xml.public_send(rule.name) do
+              if !value.nil?
+                serialized_value = attribute.type.serialize(value)
 
-          # result["_text"] = element.text if element.text
-          result
+                if attribute.type == Lutaml::Model::Type::Hash
+                  serialized_value.each do |key, val|
+                    xml.public_send(key) { xml.text val }
+                  end
+                else
+                  xml.text(serialized_value)
+                end
+              end
+            end
+          end
         end
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/MethodLength
       end
 
       class NokogiriElement < Element
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
         def initialize(node, root_node: nil)
           if root_node
             node.namespaces.each do |prefix, name|
@@ -182,10 +189,6 @@ module Lutaml
             namespace_prefix: node.namespace&.prefix,
           )
         end
-        # rubocop:enable Metrics/MethodLength
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/PerceivedComplexity
 
         def text?
           # false

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

@@ -12,14 +12,17 @@ module Lutaml
           new(root)
         end
 
-        def to_h
-          # { @root.name => parse_element(@root) }
-          parse_element(@root)
-        end
-
         def to_xml(options = {})
           builder = Ox::Builder.new
-          build_element(builder, @root, options)
+
+          if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
+            @root.to_xml(builder)
+          elsif ordered?(@root, options)
+            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
@@ -27,28 +30,25 @@ module Lutaml
 
         private
 
-        # rubocop:disable Layout/LineLength
-        # rubocop:disable Layout/MethodLength
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
-        def build_element(builder, element, _options = {})
-          return element.to_xml(builder) if element.is_a?(Lutaml::Model::XmlAdapter::OxElement)
-
-          xml_mapping = element.class.mappings_for(:xml)
+        def build_unordered_element(builder, element, options = {})
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
-          attributes = build_attributes(element, xml_mapping)
+          attributes = build_attributes(element, xml_mapping).compact
 
-          builder.element(xml_mapping.root_element, attributes) do |el|
+          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|
-              if element_rule.delegate
-                attribute_def = element.send(element_rule.delegate).class.attributes[element_rule.to]
-                value = element.send(element_rule.delegate).send(element_rule.to)
-              else
-                attribute_def = element.class.attributes[element_rule.to]
-                value = element.send(element_rule.to)
-              end
+              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
+              value = attribute_value_for(element, element_rule)
 
               val = if attribute_def.collection?
                       value
@@ -60,70 +60,104 @@ module Lutaml
 
               val.each do |v|
                 if attribute_def&.type&.<= Lutaml::Model::Serialize
-                  handle_nested_elements(el, element_rule, v)
+                  handle_nested_elements(el, v, rule: element_rule, attribute: attribute_def)
                 else
-                  builder.element(element_rule.name) do |el|
+                  builder.element(element_rule.prefixed_name) do |el|
                     el.text(attribute_def.type.serialize(v)) if v
                   end
                 end
               end
             end
-            # if element.children.any?
-            #   element.children.each do |child|
-            #     build_element(el, child, options)
-            #   end
-            # elsif element.text
-            #   el.text(element.text)
-            # 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
           end
         end
-        # rubocop:enable Layout/LineLength
-        # rubocop:enable Layout/MethodLength
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/PerceivedComplexity
-
-        def handle_nested_elements(builder, _element_rule, value)
-          case value
-          when Array
-            value.each { |val| build_element(builder, val) }
-          else
-            build_element(builder, value)
+
+        def build_ordered_element(builder, element, options = {})
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_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, mapper_class: mapper_class)
+              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)
+        def add_to_xml(xml, value, attribute, rule)
+          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+            handle_nested_elements(
+              xml,
+              value,
+              rule: rule,
+              attribute: attribute,
+            )
+          else
+            xml.element(rule.name) do |el|
+              if !value.nil?
+                serialized_value = attribute.type.serialize(value)
 
-            result[child.name] ||= []
-            result[child.name] << parse_element(child)
+                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
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Layout/LineLength
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
         def initialize(node, root_node: nil)
-          attributes = node.attributes.each_with_object({}) do |(name, value), hash|
-            if attribute_is_namespace?(name)
+          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(Lutaml::Model::XmlNamespace.new(value, name))
               else
                 add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
               end
-            else
+            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 root_node && (n = root_node.namespaces[namespace_prefix])
-                namespace = n.uri
-                prefix = n.prefix
+              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(
@@ -133,35 +167,39 @@ module Lutaml
                 namespace_prefix: prefix,
               )
             end
-          end
 
-          super(
-            node.name.to_s,
-            attributes,
-            parse_children(node, root_node: root_node || self),
-            node.text,
-            parent_document: root_node
-          )
+            super(
+              node.name.to_s,
+              attributes,
+              parse_children(node, root_node: root_node || self),
+              node.text,
+              parent_document: root_node
+            )
+          end
         end
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/MethodLength
-        # rubocop:enable Layout/LineLength
-        # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/PerceivedComplexity
 
         def to_xml(builder = nil)
           builder ||= Ox::Builder.new
           attrs = build_attributes(self)
 
-          builder.element(name, attrs) do |el|
-            if children.any?
+          if text?
+            builder.text(text)
+          else
+            builder.element(name, attrs) do |el|
               children.each { |child| child.to_xml(el) }
-            elsif text
-              el.text(text)
             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)
 
@@ -172,12 +210,14 @@ module Lutaml
           attrs
         end
 
+        def nodes
+          children
+        end
+
         private
 
         def parse_children(node, root_node: nil)
-          node.nodes.select do |child|
-            child.is_a?(Ox::Element)
-          end.map do |child|
+          node.nodes.map do |child|
             OxElement.new(child, root_node: root_node)
           end
         end