lutaml-model 0.2.1 → 0.3.0

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

@@ -12,14 +12,16 @@ 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 @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
@@ -27,28 +29,24 @@ 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)
-
+        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)
+          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)
+              value = attribute_value_for(element, element_rule)
 
               val = if attribute_def.collection?
                       value
@@ -60,70 +58,98 @@ 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, element_rule)
                 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 = {})
+          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)
+        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)
 
-            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 +159,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 +202,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

data/lib/lutaml/model/xml_adapter.rb

@@ -1,10 +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
 
@@ -33,8 +36,95 @@ module Lutaml
           declaration
         end
 
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/MethodLength
+        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)
 
@@ -52,8 +142,18 @@ module Lutaml
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/MethodLength
+
+        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
@@ -70,7 +170,6 @@ module Lutaml
                     :namespace_prefix,
                     :parent_document
 
-        # rubocop:disable Metrics/ParameterLists
         def initialize(
           name,
           attributes = {},
@@ -86,10 +185,9 @@ module Lutaml
           @text = text
           @parent_document = parent_document
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def name
-          if namespace_prefix && namespaces[namespace_prefix]
+          if namespace_prefix
             "#{namespace_prefix}:#{@name}"
           else
             @name
@@ -144,6 +242,12 @@ module Lutaml
 
           n.first
         end
+
+        def order
+          children.each_with_object([]) do |child, arr|
+            arr << child.unprefixed_name
+          end
+        end
       end
 
       class Attribute
@@ -155,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,23 @@ 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
@@ -36,8 +43,10 @@ module Lutaml
         render_nil: false,
         with: {},
         delegate: nil,
-        namespace: nil,
-        prefix: nil
+        namespace: (namespace_set = false
+                    nil),
+        prefix: nil,
+        mixed: false
       )
         @elements << XmlMappingRule.new(
           name,
@@ -47,6 +56,8 @@ module Lutaml
           delegate: delegate,
           namespace: namespace,
           prefix: prefix,
+          mixed_content: mixed,
+          namespace_set: namespace_set != false,
         )
       end
 
@@ -56,7 +67,8 @@ module Lutaml
         render_nil: false,
         with: {},
         delegate: nil,
-        namespace: nil,
+        namespace: (namespace_set = false
+                    nil),
         prefix: nil
       )
         @attributes << XmlMappingRule.new(
@@ -67,17 +79,25 @@ module Lutaml
           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)
+      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
 
@@ -108,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,8 +6,6 @@ module Lutaml
     class XmlMappingRule < MappingRule
       attr_reader :namespace, :prefix
 
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/ParameterLists
       def initialize(
         name,
         to:,
@@ -15,14 +13,18 @@ module Lutaml
         with: {},
         delegate: nil,
         namespace: nil,
-        prefix: nil
+        prefix: nil,
+        mixed_content: false,
+        namespace_set: false
       )
         super(
           name,
           to: to,
           render_nil: render_nil,
           with: with,
-          delegate: delegate
+          delegate: delegate,
+          mixed_content: mixed_content,
+          namespace_set: namespace_set
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -33,8 +35,6 @@ module Lutaml
                      end
         @prefix = prefix
       end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/ParameterLists
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 2024-08-02 00:00:00.000000000 Z
 dependencies: []
 description: 'LutaML creating data models in Ruby
 
@@ -24,6 +24,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - README.adoc
@@ -38,6 +39,7 @@ files:
 - lib/lutaml/model/json_adapter/standard.rb
 - lib/lutaml/model/key_value_mapping.rb
 - lib/lutaml/model/key_value_mapping_rule.rb
+- lib/lutaml/model/mapping_hash.rb
 - lib/lutaml/model/mapping_rule.rb
 - lib/lutaml/model/schema.rb
 - lib/lutaml/model/schema/json_schema.rb