lutaml-model 0.5.3 → 0.6.0

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

@@ -0,0 +1,32 @@
+module Lutaml
+  module Model
+    module XmlAdapter
+      class Element
+        attr_reader :type, :name
+
+        def initialize(type, name)
+          @type = type
+          @name = name
+        end
+
+        def text?
+          @type == "Text" && @name != "#cdata-section"
+        end
+
+        def element_tag
+          @name unless text?
+        end
+
+        def eql?(other)
+          return false unless other.is_a?(self.class)
+
+          instance_variables.all? do |var|
+            instance_variable_get(var) == other.instance_variable_get(var)
+          end
+        end
+
+        alias == eql?
+      end
+    end
+  end
+end

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

@@ -7,9 +7,9 @@ module Lutaml
     module XmlAdapter
       class NokogiriAdapter < XmlDocument
         def self.parse(xml, options = {})
-          parsed = Nokogiri::XML(xml, nil, options[:encoding])
-          root = NokogiriElement.new(parsed.root)
-          new(root, parsed.encoding)
+          parsed = Nokogiri::XML(xml, nil, encoding(xml, options))
+          @root = NokogiriElement.new(parsed.root)
+          new(@root, parsed.encoding)
         end
 
         def to_xml(options = {})
@@ -71,11 +71,11 @@ module Lutaml
             index_hash = {}
             content = []
 
-            element.element_order.each do |name|
-              index_hash[name] ||= -1
-              curr_index = index_hash[name] += 1
+            element.element_order.each do |object|
+              index_hash[object.name] ||= -1
+              curr_index = index_hash[object.name] += 1
 
-              element_rule = xml_mapping.find_by_name(name)
+              element_rule = xml_mapping.find_by_name(object.name)
               next if element_rule.nil?
 
               attribute_def = attribute_definition_for(element, element_rule,
@@ -83,7 +83,7 @@ module Lutaml
               value = attribute_value_for(element, element_rule)
 
               if element_rule == xml_mapping.content_mapping
-                next if element_rule.cdata && name == "text"
+                next if element_rule.cdata && object.text?
 
                 text = xml_mapping.content_mapping.serialize(element)
                 text = text[curr_index] if text.is_a?(Array)
@@ -124,7 +124,11 @@ module Lutaml
           end
 
           attributes = {}
-          node.attributes.transform_values do |attr|
+
+          # Using `attribute_nodes` instead of `attributes` because
+          # `attribute_nodes` handles name collisions as well
+          # More info: https://devdocs.io/nokogiri/nokogiri/xml/node#method-i-attributes
+          node.attribute_nodes.each do |attr|
             name = if attr.namespace
                      "#{attr.namespace.prefix}:#{attr.name}"
                    else

data/lib/lutaml/model/xml_adapter/oga/element.rb

@@ -6,21 +6,22 @@ module Lutaml
       module Oga
         class Element < XmlElement
           def initialize(node, parent: nil)
-            name = case node
-                   when ::Oga::XML::Element
-                     namespace_name = node.namespace_name
+            text = case node
+                   when Moxml::Element
+                     namespace_name = node.namespace&.prefix
                      add_namespaces(node)
                      children = parse_children(node)
                      attributes = node_attributes(node)
-                     node.name
-                   when ::Oga::XML::Text
-                     "text"
+                     @root = node
+                     node.inner_text
+                   when Moxml::Text
+                     node.content
                    end
             super(
-              name,
+              OgaAdapter.name_of(node),
               Hash(attributes),
               Array(children),
-              node.text,
+              text,
               parent_document: parent,
               namespace_prefix: namespace_name,
             )
@@ -31,7 +32,7 @@ module Lutaml
           end
 
           def text
-            @text
+            super || @text
           end
 
           def to_xml(builder = Builder::Oga.build)
@@ -61,7 +62,7 @@ module Lutaml
               next if attr_is_namespace?(attr)
 
               name = if attr.namespace
-                       "#{attr.namespace.name}:#{attr.name}"
+                       "#{attr.namespace.prefix}:#{attr.name}"
                      else
                        attr.name
                      end
@@ -69,7 +70,7 @@ module Lutaml
                 name,
                 attr.value,
                 namespace: attr.namespace&.uri,
-                namespace_prefix: attr.namespace&.name,
+                namespace_prefix: attr.namespace&.prefix,
               )
             end
           end
@@ -79,8 +80,8 @@ module Lutaml
           end
 
           def add_namespaces(node)
-            node.namespaces.each_value do |namespace|
-              add_namespace(XmlNamespace.new(namespace.uri, namespace.name))
+            node.namespaces.each do |namespace|
+              add_namespace(XmlNamespace.new(namespace.uri, namespace.prefix))
             end
           end
 

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

@@ -1,4 +1,5 @@
 require "oga"
+require "moxml/adapter/oga"
 require_relative "xml_document"
 require_relative "oga/document"
 require_relative "oga/element"
@@ -8,35 +9,105 @@ module Lutaml
   module Model
     module XmlAdapter
       class OgaAdapter < XmlDocument
+        TEXT_CLASSES = [Moxml::Text, Moxml::Cdata].freeze
+
         def self.parse(xml, options = {})
-          encoding = options[:encoding] || xml.encoding.to_s
-          xml = xml.encode("UTF-16").encode("UTF-8") if encoding && encoding != "UTF-8"
-          parsed = ::Oga.parse_xml(xml)
+          parsed = Moxml::Adapter::Oga.parse(xml)
           @root = Oga::Element.new(parsed.children.first)
-          new(@root, encoding)
+          new(@root, encoding(xml, options))
         end
 
         def to_xml(options = {})
           builder_options = {}
-
           builder_options[:encoding] = if options.key?(:encoding)
-                                         options[:encoding] || "UTF-8"
+                                         options[:encoding]
                                        elsif options.key?(:parse_encoding)
                                          options[:parse_encoding]
                                        else
                                          "UTF-8"
                                        end
-          builder = Builder::Oga.build(options) do |xml|
+
+          builder = Builder::Oga.build(builder_options) do |xml|
             if @root.is_a?(Oga::Element)
               @root.build_xml(xml)
             else
               build_element(xml, @root, options)
             end
           end
-          xml_data = builder.to_xml.encode!(builder_options[:encoding])
+          xml_data = builder.to_xml
           options[:declaration] ? declaration(options) + xml_data : xml_data
-        rescue Encoding::ConverterNotFoundError
-          invalid_encoding!(builder_options[:encoding])
+        end
+
+        def attributes_hash(element)
+          result = Lutaml::Model::MappingHash.new
+
+          element.attributes.each do |attr|
+            if attr.name == "schemaLocation"
+              result["__schema_location"] = {
+                namespace: attr.namespace,
+                prefix: attr.namespace.prefix,
+                schema_location: attr.value,
+              }
+            else
+              result[self.class.namespaced_attr_name(attr)] = attr.value
+            end
+          end
+
+          result
+        end
+
+        def self.name_of(element)
+          case element
+          when Moxml::Text
+            "text"
+          when Moxml::Cdata
+            "cdata"
+          else
+            element.name
+          end
+        end
+
+        def self.prefixed_name_of(node)
+          return name_of(node) if TEXT_CLASSES.include?(node.class)
+
+          [node&.namespace&.prefix, node.name].compact.join(":")
+        end
+
+        def self.text_of(element)
+          element.content
+        end
+
+        def self.namespaced_attr_name(attribute)
+          attr_ns = attribute.namespace
+          attr_name = attribute.name
+          return attr_name unless attr_ns
+
+          prefix = attr_name == "lang" ? attr_ns.prefix : attr_ns.uri
+          [prefix, attr_name].compact.join(":")
+        end
+
+        def self.namespaced_name_of(node)
+          return name_of(node) unless node.respond_to?(:namespace)
+
+          [node&.namespace&.uri, node.name].compact.join(":")
+        end
+
+        def order
+          children.map do |child|
+            type = child.text? ? "Text" : "Element"
+            Element.new(type, child.unprefixed_name)
+          end
+        end
+
+        def self.order_of(element)
+          element.children.map do |child|
+            instance_args = if TEXT_CLASSES.include?(child.class)
+                              ["Text", "text"]
+                            else
+                              ["Element", name_of(child)]
+                            end
+            Element.new(*instance_args)
+          end
         end
 
         private
@@ -54,18 +125,18 @@ module Lutaml
             index_hash = {}
             content = []
 
-            element.element_order.each do |name|
-              index_hash[name] ||= -1
-              curr_index = index_hash[name] += 1
+            element.element_order.each do |object|
+              index_hash[object.name] ||= -1
+              curr_index = index_hash[object.name] += 1
 
-              element_rule = xml_mapping.find_by_name(name)
+              element_rule = xml_mapping.find_by_name(object.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)
 
-              next if element_rule == xml_mapping.content_mapping && element_rule.cdata && name == "text"
+              next if element_rule == xml_mapping.content_mapping && element_rule.cdata && object.text?
 
               if element_rule == xml_mapping.content_mapping
                 text = xml_mapping.content_mapping.serialize(element)
@@ -94,10 +165,6 @@ module Lutaml
             el.add_text(el, content.join)
           end
         end
-
-        def invalid_encoding!(encoding)
-          raise Error, "unknown encoding name - #{encoding}"
-        end
       end
     end
   end

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

@@ -7,26 +7,26 @@ module Lutaml
     module XmlAdapter
       class OxAdapter < XmlDocument
         def self.parse(xml, options = {})
-          Ox.default_options = Ox.default_options.merge(encoding: options[:encoding] || "UTF-8")
+          Ox.default_options = Ox.default_options.merge(encoding: encoding(xml, options))
 
           parsed = Ox.parse(xml)
-          root = OxElement.new(parsed)
-          new(root, Ox.default_options[:encoding])
+          @root = OxElement.new(parsed)
+          new(@root, Ox.default_options[:encoding])
         end
 
         def to_xml(options = {})
           builder_options = { version: options[:version] }
 
           builder_options[:encoding] = if options.key?(:encoding)
-                                         options[:encoding]
+                                         options[:encoding] unless options[:encoding].nil?
                                        elsif options.key?(:parse_encoding)
                                          options[:parse_encoding]
                                        else
                                          "UTF-8"
                                        end
 
-          builder = Builder::Ox.build
-          builder.xml.instruct(:xml, encoding: options[:parse_encoding])
+          builder = Builder::Ox.build(builder_options)
+          builder.xml.instruct(:xml, encoding: builder_options[:encoding])
 
           if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
             @root.build_xml(builder)
@@ -39,10 +39,6 @@ module Lutaml
           end
 
           xml_data = builder.xml.to_s
-          if builder_options[:encoding] && xml_data.valid_encoding?
-            xml_data = xml_data.encode(builder_options[:encoding])
-          end
-
           stripped_data = xml_data.lines.drop(1).join
           options[:declaration] ? declaration(options) + stripped_data : stripped_data
         end
@@ -62,18 +58,18 @@ module Lutaml
             index_hash = {}
             content = []
 
-            element.element_order.each do |name|
-              index_hash[name] ||= -1
-              curr_index = index_hash[name] += 1
+            element.element_order.each do |object|
+              index_hash[object.name] ||= -1
+              curr_index = index_hash[object.name] += 1
 
-              element_rule = xml_mapping.find_by_name(name)
+              element_rule = xml_mapping.find_by_name(object.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)
 
-              next if element_rule == xml_mapping.content_mapping && element_rule.cdata && name == "text"
+              next if element_rule == xml_mapping.content_mapping && element_rule.cdata && object.text?
 
               if element_rule == xml_mapping.content_mapping
                 text = element.send(xml_mapping.content_mapping.to)
@@ -198,6 +194,14 @@ module Lutaml
           children
         end
 
+        def cdata
+          super || cdata_children.first&.text
+        end
+
+        def text
+          super || cdata
+        end
+
         private
 
         def parse_children(node, root_node: nil)

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

@@ -2,6 +2,7 @@ require_relative "../mapping_hash"
 require_relative "xml_element"
 require_relative "xml_attribute"
 require_relative "xml_namespace"
+require_relative "element"
 
 module Lutaml
   module Model
@@ -22,6 +23,22 @@ module Lutaml
           @root.children
         end
 
+        def root
+          @root
+        end
+
+        def attributes
+          root.attributes
+        end
+
+        def self.encoding(xml, options)
+          if options.key?(:encoding)
+            options[:encoding]
+          else
+            xml.encoding.to_s
+          end
+        end
+
         def declaration(options)
           version = "1.0"
           version = options[:declaration] if options[:declaration].is_a?(String)
@@ -75,28 +92,33 @@ module Lutaml
         def parse_element(element, klass = nil, format = nil)
           result = Lutaml::Model::MappingHash.new
           result.node = element
-          result.item_order = element.order
+          result.item_order = self.class.order_of(element)
 
-          element.children.each_with_object(result) do |child, hash|
+          element.children.each do |child|
             if klass&.<= Serialize
-              attr = klass.attribute_for_child(child.name,
+              attr = klass.attribute_for_child(self.class.name_of(child),
                                                format)
             end
 
-            value = if child.text?
-                      child.text
-                    else
-                      parse_element(child, attr&.type || klass, format)
-                    end
-
-            hash[child.namespaced_name] = if hash[child.namespaced_name]
-                                            [hash[child.namespaced_name], value].flatten
-                                          else
-                                            value
-                                          end
+            if child.respond_to?(:text?) && child.text?
+              result.assign_or_append_value(
+                self.class.name_of(child),
+                self.class.text_of(child),
+              )
+              next
+            end
+
+            result["elements"] ||= Lutaml::Model::MappingHash.new
+            result["elements"].assign_or_append_value(
+              self.class.namespaced_name_of(child),
+              parse_element(child, attr&.type || klass, format),
+            )
           end
 
+          result["attributes"] = attributes_hash(element) if element.attributes&.any?
+
           result.merge(attributes_hash(element))
+          result
         end
 
         def attributes_hash(element)
@@ -126,14 +148,6 @@ module Lutaml
         end
 
         def add_to_xml(xml, element, prefix, value, options = {})
-          if value.is_a?(Array)
-            value.each do |item|
-              add_to_xml(xml, element, prefix, item, options)
-            end
-
-            return
-          end
-
           attribute = options[:attribute]
           rule = options[:rule]
 
@@ -143,6 +157,19 @@ module Lutaml
             return
           end
 
+          # Only transform when recursion is not called
+          if (!attribute.collection? || value.is_a?(Array)) && transform_method = rule.transform[:export] || attribute.transform_export_method
+            value = transform_method.call(value)
+          end
+
+          if value.is_a?(Array)
+            value.each do |item|
+              add_to_xml(xml, element, prefix, item, options)
+            end
+
+            return
+          end
+
           return if !render_element?(rule, element, value)
 
           if value && (attribute&.type&.<= Lutaml::Model::Serialize)
@@ -166,9 +193,10 @@ module Lutaml
 
         def add_value(xml, value, attribute, cdata: false)
           if !value.nil?
-            serialized_value = attribute.type.serialize(value)
-
-            if attribute.type == Lutaml::Model::Type::Hash
+            serialized_value = attribute.serialize(value, :xml)
+            if attribute.raw?
+              xml.add_xml_fragment(xml, value)
+            elsif attribute.type == Lutaml::Model::Type::Hash
               serialized_value.each do |key, val|
                 xml.create_and_add_element(key) do |element|
                   element.text(val)
@@ -343,6 +371,9 @@ module Lutaml
             end
 
             value = mapping_rule.to_value_for(element)
+            attr = attribute_definition_for(element, mapping_rule, mapper_class: options[:mapper_class])
+            value = attr.serialize(value, :xml) if attr
+
             if render_element?(mapping_rule, element, value)
               hash[mapping_rule.prefixed_name] = value ? value.to_s : value
             end
@@ -380,6 +411,32 @@ module Lutaml
         def self.type
           Utils.snake_case(self).split("/").last.split("_").first
         end
+
+        def self.order_of(element)
+          element.order
+        end
+
+        def self.name_of(element)
+          element.name
+        end
+
+        def self.text_of(element)
+          element.text
+        end
+
+        def self.namespaced_name_of(element)
+          element.namespaced_name
+        end
+
+        def text
+          return @root.text_children.map(&:text) if @root.children.count > 1
+
+          @root.text
+        end
+
+        def cdata
+          @root.cdata
+        end
       end
     end
   end

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

@@ -8,7 +8,8 @@ module Lutaml
                     :children,
                     :text,
                     :namespace_prefix,
-                    :parent_document
+                    :parent_document,
+                    :default_namespace
 
         attr_accessor :adapter_node
 
@@ -117,10 +118,63 @@ module Lutaml
         end
 
         def order
-          children.each_with_object([]) do |child, arr|
-            arr << child.unprefixed_name
+          children.map do |child|
+            type = child.text? ? "Text" : "Element"
+            Lutaml::Model::XmlAdapter::Element.new(type, child.unprefixed_name)
           end
         end
+
+        def root
+          self
+        end
+
+        def text
+          return text_children.map(&:text) if children.count > 1
+
+          @text
+        end
+
+        def cdata_children
+          find_children_by_name("#cdata-section")
+        end
+
+        def text_children
+          find_children_by_name("text")
+        end
+
+        def find_attribute_value(attribute_name)
+          if attribute_name.is_a?(Array)
+            attributes.values.find do |attr|
+              attribute_name.include?(attr.namespaced_name)
+            end&.value
+          else
+            attributes.values.find do |attr|
+              attribute_name == attr.namespaced_name
+            end&.value
+          end
+        end
+
+        def find_children_by_name(name)
+          if name.is_a?(Array)
+            children.select { |child| name.include?(child.namespaced_name) }
+          else
+            children.select { |child| child.namespaced_name == name }
+          end
+        end
+
+        def find_child_by_name(name)
+          find_children_by_name(name).first
+        end
+
+        def cdata
+          return cdata_children.map(&:text) if children.count > 1
+
+          @text
+        end
+
+        def to_h
+          document.to_h
+        end
       end
     end
   end