lutaml-model 0.7.1 → 0.7.7

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

@@ -0,0 +1,234 @@
+require "nokogiri"
+require_relative "document"
+require_relative "builder/nokogiri"
+
+module Lutaml
+  module Model
+    module Xml
+      class NokogiriAdapter < Document
+        def self.parse(xml, options = {})
+          parsed = Nokogiri::XML(xml, nil, encoding(xml, options))
+          @root = NokogiriElement.new(parsed.root)
+          new(@root, parsed.encoding)
+        end
+
+        def to_xml(options = {})
+          builder_options = {}
+
+          if options.key?(:encoding)
+            builder_options[:encoding] = options[:encoding] unless options[:encoding].nil?
+          elsif options.key?(:parse_encoding)
+            builder_options[:encoding] = options[:parse_encoding]
+          else
+            builder_options[:encoding] = "UTF-8"
+          end
+
+          builder = Builder::Nokogiri.build(builder_options) do |xml|
+            if root.is_a?(Lutaml::Model::Xml::NokogiriElement)
+              root.build_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 = {}
+          xml_options[:indent] = 2 if options[:pretty]
+
+          xml_data = builder.doc.root.to_xml(xml_options)
+          options[:declaration] ? declaration(options) + xml_data : xml_data
+        end
+
+        private
+
+        def prefix_xml(xml, mapping, options)
+          if options.key?(:namespace_prefix)
+            xml[options[:namespace_prefix]] if options[:namespace_prefix]
+          elsif mapping.namespace_prefix
+            xml[mapping.namespace_prefix]
+          end
+          xml
+        end
+
+        def build_ordered_element(xml, element, options = {})
+          mapper_class = determine_mapper_class(element, options)
+          xml_mapping = mapper_class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = build_attributes(element, xml_mapping)&.compact
+
+          prefixed_xml = prefix_xml(xml, xml_mapping, options)
+
+          tag_name = options[:tag_name] || xml_mapping.root_element
+          tag_name = "#{tag_name}_" if prefixed_xml.respond_to?(tag_name)
+          prefixed_xml.public_send(tag_name, attributes) do
+            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
+              xml.parent.namespace = nil
+            end
+
+            index_hash = {}
+            content = []
+
+            element.element_order.each do |object|
+              object_key = "#{object.name}-#{object.type}"
+              index_hash[object_key] ||= -1
+              curr_index = index_hash[object_key] += 1
+
+              element_rule = xml_mapping.find_by_name(object.name, type: object.type)
+              next if element_rule.nil?
+
+              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
+                next if element_rule.cdata && object.text?
+
+                text = xml_mapping.content_mapping.serialize(element)
+                text = text[curr_index] if text.is_a?(Array)
+
+                next prefixed_xml.add_text(xml, text, cdata: element_rule.cdata) if element.mixed?
+
+                content << text
+              elsif !value.nil? || element_rule.render_nil?
+                value = value[curr_index] if attribute_def.collection?
+
+                add_to_xml(
+                  xml,
+                  element,
+                  element_rule.prefix,
+                  value,
+                  options.merge(
+                    attribute: attribute_def,
+                    rule: element_rule,
+                    mapper_class: mapper_class,
+                  ),
+                )
+              end
+            end
+
+            prefixed_xml.text content.join
+          end
+        end
+      end
+
+      class NokogiriElement < XmlElement
+        def initialize(node, root_node: nil, default_namespace: nil)
+          if root_node
+            node.namespaces.each do |prefix, name|
+              namespace = XmlNamespace.new(name, prefix)
+
+              root_node.add_namespace(namespace)
+            end
+          end
+
+          attributes = {}
+
+          # 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
+                     attr.name
+                   end
+
+            attributes[name] = XmlAttribute.new(
+              name,
+              attr.value,
+              namespace: attr.namespace&.href,
+              namespace_prefix: attr.namespace&.prefix,
+            )
+          end
+
+          if root_node.nil? && !node.namespace&.prefix
+            default_namespace = node.namespace&.href
+          end
+
+          super(
+            node,
+            attributes,
+            parse_all_children(node, root_node: root_node || self,
+                                     default_namespace: default_namespace),
+            node.text,
+            name: node.name,
+            parent_document: root_node,
+            namespace_prefix: node.namespace&.prefix,
+            default_namespace: default_namespace
+          )
+        end
+
+        def text?
+          # false
+          children.empty? && text.length.positive?
+        end
+
+        def to_xml
+          return text if text?
+
+          build_xml.doc.root.to_xml
+        end
+
+        def inner_xml
+          children.map(&:to_xml).join
+        end
+
+        def build_xml(builder = nil)
+          builder ||= Builder::Nokogiri.build
+
+          if name == "text"
+            builder.text(text)
+          else
+            builder.public_send(name, build_attributes(self)) do |xml|
+              children.each do |child|
+                child.build_xml(xml)
+              end
+            end
+          end
+
+          builder
+        end
+
+        private
+
+        def parse_children(node, root_node: nil)
+          node.children.select(&:element?).map do |child|
+            NokogiriElement.new(child, root_node: root_node)
+          end
+        end
+
+        def parse_all_children(node, root_node: nil, default_namespace: nil)
+          node.children.map do |child|
+            NokogiriElement.new(child, root_node: root_node,
+                                       default_namespace: default_namespace)
+          end
+        end
+
+        def build_attributes(node, _options = {})
+          attrs = node.attributes.transform_values(&:value)
+
+          attrs.merge(build_namespace_attributes(node))
+        end
+
+        def build_namespace_attributes(node)
+          namespace_attrs = {}
+
+          node.own_namespaces.each_value do |namespace|
+            namespace_attrs[namespace.attr_name] = namespace.uri
+          end
+
+          node.children.each do |child|
+            namespace_attrs = namespace_attrs.merge(
+              build_namespace_attributes(child),
+            )
+          end
+
+          namespace_attrs
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/{xml_adapter → xml}/oga/document.rb

@@ -2,7 +2,7 @@
 
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       module Oga
         class Document < ::Oga::XML::Document
           def initialize(options = {})

data/lib/lutaml/model/{xml_adapter → xml}/oga/element.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "../xml_element"
+
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       module Oga
         class Element < XmlElement
           def initialize(node, parent: nil)
@@ -17,11 +19,14 @@ module Lutaml
                    when Moxml::Text
                      node.content
                    end
+
+            name = OgaAdapter.name_of(node)
             super(
-              OgaAdapter.name_of(node),
+              name,
               Hash(attributes),
               Array(children),
               text,
+              name: name,
               parent_document: parent,
               namespace_prefix: namespace_name,
             )

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

@@ -0,0 +1,172 @@
+require "oga"
+require "moxml/adapter/oga"
+require_relative "document"
+require_relative "oga/document"
+require_relative "oga/element"
+require_relative "builder/oga"
+
+module Lutaml
+  module Model
+    module Xml
+      class OgaAdapter < Document
+        TEXT_CLASSES = [Moxml::Text, Moxml::Cdata].freeze
+
+        def self.parse(xml, options = {})
+          parsed = Moxml::Adapter::Oga.parse(xml)
+          @root = Oga::Element.new(parsed.children.first)
+          new(@root, encoding(xml, options))
+        end
+
+        def to_xml(options = {})
+          builder_options = {}
+          builder_options[:encoding] = if options.key?(:encoding)
+                                         options[:encoding]
+                                       elsif options.key?(:parse_encoding)
+                                         options[:parse_encoding]
+                                       else
+                                         "UTF-8"
+                                       end
+
+          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
+          options[:declaration] ? declaration(options) + xml_data : xml_data
+        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
+
+        def build_ordered_element(builder, element, options = {})
+          mapper_class = determine_mapper_class(element, options)
+          xml_mapping = mapper_class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = build_attributes(element, xml_mapping).compact
+
+          tag_name = options[:tag_name] || xml_mapping.root_element
+          builder.create_and_add_element(tag_name,
+                                         attributes: attributes) do |el|
+            index_hash = {}
+            content = []
+
+            element.element_order.each do |object|
+              object_key = "#{object.name}-#{object.type}"
+              index_hash[object_key] ||= -1
+              curr_index = index_hash[object_key] += 1
+
+              element_rule = xml_mapping.find_by_name(object.name, type: object.type)
+              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 && object.text?
+
+              if element_rule == xml_mapping.content_mapping
+                text = xml_mapping.content_mapping.serialize(element)
+                text = text[curr_index] if text.is_a?(Array)
+
+                next el.add_text(el, text, cdata: element_rule.cdata) if element.mixed?
+
+                content << text
+              elsif !value.nil? || element_rule.render_nil?
+                value = value[curr_index] if attribute_def.collection?
+
+                add_to_xml(
+                  el,
+                  element,
+                  nil,
+                  value,
+                  options.merge(
+                    attribute: attribute_def,
+                    rule: element_rule,
+                    mapper_class: mapper_class,
+                  ),
+                )
+              end
+            end
+
+            el.add_text(el, content.join)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,229 @@
+require "ox"
+require_relative "document"
+require_relative "builder/ox"
+
+module Lutaml
+  module Model
+    module Xml
+      class OxAdapter < Document
+        def self.parse(xml, options = {})
+          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])
+        end
+
+        def to_xml(options = {})
+          builder_options = { version: options[:version] }
+
+          builder_options[:encoding] = if options.key?(:encoding)
+                                         options[:encoding] unless options[:encoding].nil?
+                                       elsif options.key?(:parse_encoding)
+                                         options[:parse_encoding]
+                                       else
+                                         "UTF-8"
+                                       end
+
+          builder = Builder::Ox.build(builder_options)
+          builder.xml.instruct(:xml, encoding: builder_options[:encoding])
+
+          if @root.is_a?(Lutaml::Model::Xml::OxElement)
+            @root.build_xml(builder)
+          elsif ordered?(@root, options)
+            build_ordered_element(builder, @root, options)
+          else
+            mapper_class = options[:mapper_class] || @root.class
+            options[:xml_attributes] = build_namespace_attributes(mapper_class)
+            build_element(builder, @root, options)
+          end
+
+          xml_data = builder.xml.to_s
+          stripped_data = xml_data.lines.drop(1).join
+          options[:declaration] ? declaration(options) + stripped_data : stripped_data
+        end
+
+        private
+
+        def build_ordered_element(builder, element, options = {})
+          mapper_class = determine_mapper_class(element, options)
+          xml_mapping = mapper_class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = build_attributes(element, xml_mapping).compact
+
+          tag_name = options[:tag_name] || xml_mapping.root_element
+          builder.create_and_add_element(tag_name,
+                                         attributes: attributes) do |el|
+            index_hash = {}
+            content = []
+
+            element.element_order.each do |object|
+              object_key = "#{object.name}-#{object.type}"
+              index_hash[object_key] ||= -1
+              curr_index = index_hash[object_key] += 1
+
+              element_rule = xml_mapping.find_by_name(object.name, type: object.type)
+              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 && object.text?
+
+              if element_rule == xml_mapping.content_mapping
+                text = element.send(xml_mapping.content_mapping.to)
+                text = text[curr_index] if text.is_a?(Array)
+
+                next el.add_text(el, text, cdata: element_rule.cdata) if element.mixed?
+
+                content << text
+              elsif !value.nil? || element_rule.render_nil?
+                value = value[curr_index] if attribute_def.collection?
+
+                add_to_xml(
+                  el,
+                  element,
+                  nil,
+                  value,
+                  options.merge(
+                    attribute: attribute_def,
+                    rule: element_rule,
+                  ),
+                )
+              end
+            end
+
+            el.add_text(el, content.join)
+          end
+        end
+      end
+
+      class OxElement < XmlElement
+        def initialize(node, root_node: nil)
+          case node
+          when String
+            super("text", {}, [], node, parent_document: root_node, name: "text")
+          when Ox::Comment
+            super("comment", {}, [], node.value, parent_document: root_node, name: "comment")
+          when Ox::CData
+            super("#cdata-section", {}, [], node.value, parent_document: root_node, name: "#cdata-section")
+          else
+            namespace_attributes(node.attributes).each do |(name, value)|
+              if root_node
+                root_node.add_namespace(XmlNamespace.new(value, name))
+              else
+                add_namespace(XmlNamespace.new(value, name))
+              end
+            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 (n = name.to_s.split(":")).length > 1
+                namespace = (root_node || self).namespaces[namespace_prefix]&.uri
+                namespace ||= XML_NAMESPACE_URI
+                prefix = n.first
+              end
+
+              hash[name.to_s] = XmlAttribute.new(
+                name.to_s,
+                value,
+                namespace: namespace,
+                namespace_prefix: prefix,
+              )
+            end
+
+            prefix, name = separate_name_and_prefix(node)
+
+            super(
+              node,
+              attributes,
+              parse_children(node, root_node: root_node || self),
+              node.text,
+              parent_document: root_node,
+              name: name,
+              namespace_prefix: prefix,
+            )
+          end
+        end
+
+        def separate_name_and_prefix(node)
+          name = node.name.to_s
+
+          return [nil, name] unless name.include?(":")
+
+          prefix, _, name = name.partition(":")
+          [prefix, name]
+        end
+
+        def to_xml
+          return text if text?
+
+          build_xml.xml.to_s
+        end
+
+        def inner_xml
+          # Ox builder by default, adds a newline at the end, so `chomp` is used
+          children.map { |child| child.to_xml.chomp }.join
+        end
+
+        def build_xml(builder = nil)
+          builder ||= Builder::Ox.build
+          attrs = build_attributes(self)
+
+          if text?
+            builder.add_text(builder, text)
+          else
+            builder.create_and_add_element(name, attributes: attrs) do |el|
+              children.each { |child| child.build_xml(el) }
+            end
+          end
+
+          builder
+        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)
+
+          node.own_namespaces.each_value do |namespace|
+            attrs[namespace.attr_name] = namespace.uri
+          end
+
+          attrs
+        end
+
+        def nodes
+          children
+        end
+
+        def cdata
+          super || cdata_children.first&.text
+        end
+
+        def text
+          super || cdata
+        end
+
+        private
+
+        def parse_children(node, root_node: nil)
+          node.nodes.map do |child|
+            OxElement.new(child, root_node: root_node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml/transform.rb

@@ -0,0 +1,8 @@
+module Lutaml
+  module Model
+    module Xml
+      class Transform < Lutaml::Model::XmlTransform
+      end
+    end
+  end
+end

data/lib/lutaml/model/{xml_adapter → xml}/xml_attribute.rb

@@ -2,7 +2,7 @@
 
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       # Represents an XML attribute
       class XmlAttribute
         attr_reader :name, :value, :namespace, :namespace_prefix