lutaml-model 0.5.4 → 0.6.0

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,22 +92,32 @@ 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 do |child|
             if klass&.<= Serialize
-              attr = klass.attribute_for_child(child.name,
+              attr = klass.attribute_for_child(self.class.name_of(child),
                                                format)
             end
 
-            next result.assign_or_append_value(child.name, child.text) if child.text?
+            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(child.namespaced_name, parse_element(child, attr&.type || klass, format))
+            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
 
@@ -121,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]
 
@@ -138,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)
@@ -161,7 +193,7 @@ module Lutaml
 
         def add_value(xml, value, attribute, cdata: false)
           if !value.nil?
-            serialized_value = attribute.type.serialize(value)
+            serialized_value = attribute.serialize(value, :xml)
             if attribute.raw?
               xml.add_xml_fragment(xml, value)
             elsif attribute.type == Lutaml::Model::Type::Hash
@@ -339,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
@@ -376,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

data/lib/lutaml/model/xml_mapping.rb

@@ -16,11 +16,13 @@ module Lutaml
                   :namespace_uri,
                   :namespace_prefix,
                   :mixed_content,
-                  :ordered
+                  :ordered,
+                  :element_sequence
 
       def initialize
         @elements = {}
         @attributes = {}
+        @element_sequence = []
         @content_mapping = nil
         @raw_mapping = nil
         @mixed_content = false
@@ -35,6 +37,18 @@ module Lutaml
         @ordered = ordered || mixed # mixed contenet will always be ordered
       end
 
+      def root?
+        !!root_element
+      end
+
+      def no_root
+        @no_root = true
+      end
+
+      def no_root?
+        !!@no_root
+      end
+
       def prefixed_root
         if namespace_uri && namespace_prefix
           "#{namespace_prefix}:#{root_element}"
@@ -44,6 +58,8 @@ module Lutaml
       end
 
       def namespace(uri, prefix = nil)
+        raise Lutaml::Model::NoRootNamespaceError if no_root?
+
         @namespace_uri = uri
         @namespace_prefix = prefix
       end
@@ -60,7 +76,8 @@ module Lutaml
         namespace: (namespace_set = false
                     nil),
         prefix: (prefix_set = false
-                 nil)
+                 nil),
+        transform: {}
       )
         validate!(name, to, with, type: TYPES[:element])
 
@@ -77,6 +94,7 @@ module Lutaml
           prefix: prefix,
           namespace_set: namespace_set != false,
           prefix_set: prefix_set != false,
+          transform: transform,
         )
         @elements[rule.namespaced_name] = rule
       end
@@ -170,6 +188,21 @@ module Lutaml
 
       alias map_all_content map_all
 
+      def sequence(&block)
+        @element_sequence << Sequence.new(self).tap do |s|
+          s.instance_eval(&block)
+        end
+      end
+
+      def import_model_mappings(model)
+        raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+
+        mappings = model.mappings_for(:xml)
+        @elements.merge!(mappings.instance_variable_get(:@elements))
+        @attributes.merge!(mappings.instance_variable_get(:@attributes))
+        (@element_sequence << mappings.element_sequence).flatten!
+      end
+
       def validate!(key, to, with, type: nil)
         validate_mappings!(type)
 
@@ -243,14 +276,23 @@ module Lutaml
                                               ordered: @ordered)
           xml_mapping.namespace(@namespace_uri.dup, @namespace_prefix.dup)
 
-          xml_mapping.instance_variable_set(:@attributes,
-                                            dup_mappings(@attributes))
-          xml_mapping.instance_variable_set(:@elements, dup_mappings(@elements))
-          xml_mapping.instance_variable_set(:@content_mapping,
-                                            @content_mapping&.deep_dup)
+          attributes_to_dup.each do |var_name|
+            value = instance_variable_get(var_name)
+            xml_mapping.instance_variable_set(var_name, Utils.deep_dup(value))
+          end
         end
       end
 
+      def attributes_to_dup
+        @attributes_to_dup ||= %i[
+          @content_mapping
+          @raw_mapping
+          @element_sequence
+          @attributes
+          @elements
+        ]
+      end
+
       def dup_mappings(mappings)
         new_mappings = {}
 

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -19,7 +19,8 @@ module Lutaml
         namespace_set: false,
         prefix_set: false,
         attribute: false,
-        default_namespace: nil
+        default_namespace: nil,
+        transform: {}
       )
         super(
           name,
@@ -28,7 +29,8 @@ module Lutaml
           render_default: render_default,
           with: with,
           delegate: delegate,
-          attribute: attribute
+          attribute: attribute,
+          transform: transform
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -101,15 +103,18 @@ module Lutaml
           name.dup,
           to: to,
           render_nil: render_nil,
+          render_default: render_default,
           with: Utils.deep_dup(custom_methods),
           delegate: delegate,
           namespace: namespace.dup,
           prefix: prefix.dup,
           mixed_content: mixed_content,
+          cdata: cdata,
           namespace_set: namespace_set?,
-          attribute: attribute,
           prefix_set: prefix_set?,
+          attribute: attribute,
           default_namespace: default_namespace.dup,
+          transform: transform.dup,
         )
       end
     end

data/lib/lutaml/model.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "moxml"
 require_relative "model/version"
 require_relative "model/loggable"
 require_relative "model/type"