lutaml-model 0.2.1 → 0.3.0

data/lib/lutaml/model/serialize.rb

@@ -1,14 +1,11 @@
 # lib/lutaml/model/serialize.rb
-require_relative "json_adapter/standard"
-require_relative "json_adapter/multi_json"
 require_relative "yaml_adapter"
 require_relative "xml_adapter"
-require_relative "toml_adapter/toml_rb_adapter"
-require_relative "toml_adapter/tomlib_adapter"
 require_relative "config"
 require_relative "type"
 require_relative "attribute"
 require_relative "mapping_rule"
+require_relative "mapping_hash"
 require_relative "xml_mapping"
 require_relative "key_value_mapping"
 require_relative "json_adapter"
@@ -22,14 +19,15 @@ module Lutaml
         base.extend(ClassMethods)
       end
 
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/BlockLength
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
       module ClassMethods
         attr_accessor :attributes, :mappings
 
+        def inherited(subclass)
+          super
+
+          subclass.instance_variable_set(:@attributes, @attributes.dup)
+        end
+
         def attribute(name, type, options = {})
           self.attributes ||= {}
           attr = Attribute.new(name, type, options)
@@ -50,13 +48,17 @@ module Lutaml
             klass = format == :xml ? XmlMapping : KeyValueMapping
             self.mappings[format] = klass.new
             self.mappings[format].instance_eval(&block)
+
+            if format == :xml && !self.mappings[format].root_element
+              self.mappings[format].root(to_s)
+            end
           end
 
           define_method(:"from_#{format}") do |data|
             adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
             doc = adapter.parse(data)
             mapped_attrs = apply_mappings(doc.to_h, format)
-            apply_content_mapping(doc, mapped_attrs) if format == :xml
+            # apply_content_mapping(doc, mapped_attrs) if format == :xml
             new(mapped_attrs)
           end
         end
@@ -79,7 +81,7 @@ module Lutaml
           return apply_xml_mapping(doc) if format == :xml
 
           mappings = mappings_for(format).mappings
-          mappings.each_with_object({}) do |rule, hash|
+          mappings.each_with_object(Lutaml::Model::MappingHash.new) do |rule, hash|
             attr = if rule.delegate
                      attributes[rule.delegate].type.attributes[rule.to]
                    else
@@ -95,15 +97,6 @@ module Lutaml
                     else
                       attr.default
                     end
-            # if attr.collection?
-            #   value = (value || []).map do |v|
-            #     attr.type <= Serialize ? attr.type.new(v) : v
-            #   end
-            # elsif value.is_a?(Hash) && attr.type <= Serialize
-            #   value = attr.type.new(value)
-            # else
-            #   value = attr.type.cast(value)
-            # end
 
             if attr.collection?
               value = (value || []).map do |v|
@@ -122,93 +115,116 @@ module Lutaml
           end
         end
 
-        def apply_xml_mapping(doc)
+        def apply_xml_mapping(doc, caller_class: nil, mixed_content: false)
+          return unless doc
+
           mappings = mappings_for(:xml).mappings
 
-          mappings.each_with_object({}) do |rule, hash|
+          if doc.is_a?(Array)
+            raise "May be `collection: true` is" \
+                  "missing for #{self} in #{caller_class}"
+          end
+
+          mapping_hash = Lutaml::Model::MappingHash.new
+          mapping_hash.item_order = doc.item_order
+          mapping_hash.ordered = mappings_for(:xml).mixed_content? || mixed_content
+
+          mappings.each_with_object(mapping_hash) do |rule, hash|
             attr = attributes[rule.to]
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
 
-            value = if rule.name
-                      doc[rule.name.to_s] || doc[rule.name.to_sym]
-                    else
+            is_content_mapping = rule.name.nil?
+            value = if is_content_mapping
                       doc["text"]
+                    else
+                      doc[rule.name.to_s] || doc[rule.name.to_sym]
                     end
 
-            # if attr.collection?
-            #   value = (value || []).map do |v|
-            #     attr.type <= Serialize ? attr.type.from_hash(v) : v
-            #   end
-            # elsif value.is_a?(Hash) && attr.type <= Serialize
-            #   value = attr.type.cast(value)
-            # elsif value.is_a?(Array)
-            #   value = attr.type.cast(value.first["text"]&.first)
-            # end
-
             if attr.collection?
+              if value && !value.is_a?(Array)
+                value = [value]
+              end
+
               value = (value || []).map do |v|
                 if attr.type <= Serialize
-                  attr.type.apply_xml_mapping(v)
-                else
+                  attr.type.apply_xml_mapping(v, caller_class: self, mixed_content: rule.mixed_content)
+                elsif v.is_a?(Hash)
                   v["text"]
+                else
+                  v
                 end
               end
             elsif attr.type <= Serialize
-              value = attr.type.apply_xml_mapping(value) if value
+              value = attr.type.apply_xml_mapping(value, caller_class: self, mixed_content: rule.mixed_content)
             else
               if value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
                 value = value["text"]
               end
 
-              value = attr.type.cast(value)
+              value = attr.type.cast(value) unless is_content_mapping
             end
+
             hash[rule.to] = value
           end
         end
-
-        def apply_content_mapping(doc, mapped_attrs)
-          content_mapping = mappings_for(:xml).content_mapping
-          return unless content_mapping
-
-          content = doc.root.children.select(&:text?).map(&:text)
-          mapped_attrs[content_mapping.to] = content
-        end
       end
 
-      # rubocop:disable Layout/LineLength
+      attr_reader :element_order
+
       def initialize(attrs = {})
         return unless self.class.attributes
 
+        if attrs.is_a?(Lutaml::Model::MappingHash)
+          @ordered = attrs.ordered?
+          @element_order = attrs.item_order
+        end
+
         self.class.attributes.each do |name, attr|
-          value = if attrs.key?(name)
-                    attrs[name]
-                  elsif attrs.key?(name.to_sym)
-                    attrs[name.to_sym]
-                  elsif attrs.key?(name.to_s)
-                    attrs[name.to_s]
-                  else
-                    attr.default
-                  end
+          value = attr_value(attrs, name, attr)
 
-          value = if attr.collection?
-                    (value || []).map do |v|
-                      if v.is_a?(Hash)
-                        attr.type.new(v)
-                      else
-                        Lutaml::Model::Type.cast(
-                          v, attr.type
-                        )
-                      end
-                    end
-                  elsif value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
-                    attr.type.new(value)
-                  else
-                    Lutaml::Model::Type.cast(value, attr.type)
-                  end
           send(:"#{name}=", ensure_utf8(value))
         end
       end
-      # rubocop:enable Layout/LineLength
+
+      def attr_value(attrs, name, attr_rule)
+        value = if attrs.key?(name)
+                  attrs[name]
+                elsif attrs.key?(name.to_sym)
+                  attrs[name.to_sym]
+                elsif attrs.key?(name.to_s)
+                  attrs[name.to_s]
+                else
+                  attr_rule.default
+                end
+
+        if attr_rule.collection? || value.is_a?(Array)
+          (value || []).map do |v|
+            if v.is_a?(Hash)
+              attr_rule.type.new(v)
+            else
+              Lutaml::Model::Type.cast(
+                v, attr_rule.type
+              )
+            end
+          end
+        elsif value.is_a?(Hash) && attr_rule.type != Lutaml::Model::Type::Hash
+          attr_rule.type.new(value)
+        else
+          Lutaml::Model::Type.cast(value, attr_rule.type)
+        end
+      end
+
+      def ordered?
+        @ordered
+      end
+
+      def key_exist?(hash, key)
+        hash.key?(key) || hash.key?(key.to_sym) || hash.key?(key.to_s)
+      end
+
+      def key_value(hash, key)
+        hash[key] || hash[key.to_sym] || hash[key.to_s]
+      end
 
       # TODO: Make this work
       # FORMATS.each do |format|
@@ -325,11 +341,6 @@ module Lutaml
           value
         end
       end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/BlockLength
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end

data/lib/lutaml/model/type.rb

@@ -74,6 +74,24 @@ module Lutaml
         end
       end
 
+      class TextWithTags
+        attr_reader :content
+
+        def initialize(ordered_text_with_tags)
+          @content = ordered_text_with_tags
+        end
+
+        def self.cast(value)
+          return value if value.is_a?(self)
+
+          new(value)
+        end
+
+        def self.serialize(value)
+          value.content.join
+        end
+      end
+
       class JSON
         attr_reader :value
 
@@ -94,7 +112,7 @@ module Lutaml
         end
 
         def self.cast(value)
-          return value if value.is_a?(self)
+          return value if value.is_a?(self) || value.nil?
 
           new(::JSON.parse(value))
         end
@@ -104,15 +122,8 @@ module Lutaml
         end
       end
 
-      # rubocop:disable Layout/LineLength
       UUID_REGEX = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
-      # rubocop:enable Layout/LineLength
 
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Layout/LineLength
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
       def self.cast(value, type)
         return if value.nil?
 
@@ -203,11 +214,6 @@ module Lutaml
           end
         end.to_h
       end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Layout/LineLength
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

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

@@ -12,14 +12,14 @@ 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)
+            if root.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
+              root.to_xml(xml)
+            else
+              options[:xml_attributes] = build_namespace_attributes(@root.class)
+              build_element(xml, @root, options)
+            end
           end
 
           xml_options = {}
@@ -31,123 +31,122 @@ 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
-
+        def build_unordered_element(xml, element, options = {})
           xml_mapping = element.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)
+              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 = {})
+          xml_mapping = element.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)
+              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
 
-          # result["_text"] = element.text if element.text
-          result
+        def add_to_xml(xml, value, attribute, rule)
+          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+            handle_nested_elements(xml, value, rule)
+          else
+            xml.public_send(rule.name) do
+              if !value.nil?
+                serialized_value = attribute.type.serialize(value)
+
+                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 +181,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