lutaml-model 0.7.1 → 0.7.2

data/lib/lutaml/model/xml.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Xml
+      def self.detect_xml_adapter
+        return :nokogiri if Object.const_defined?(:Nokogiri)
+        return :ox if Object.const_defined?(:Ox)
+        return :opal if Object.const_defined?(:Opal)
+
+        nil
+      end
+    end
+  end
+end
+
+require_relative "xml/document"
+require_relative "xml/mapping"
+require_relative "xml/mapping_rule"
+require_relative "xml/transform"
+
+Lutaml::Model::FormatRegistry.register(
+  :xml,
+  mapping_class: Lutaml::Model::Xml::Mapping,
+  adapter_class: nil,
+  transformer: Lutaml::Model::Xml::Transform,
+)
+
+if (adapter = Lutaml::Model::Xml.detect_xml_adapter)
+  Lutaml::Model::Config.xml_adapter_type = adapter
+end

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

@@ -1,31 +1,17 @@
+# require "ox"
+# require_relative "xml_document"
+# require_relative "builder/ox"
+
+require_relative "../xml/element"
+
 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?
+      class Element < ::Lutaml::Model::Xml::Element
+        Logger.warn_future_deprication(
+          old: "Lutaml::Model::XmlAdapter::Element",
+          replacement: "Lutaml::Model::Xml::Element",
+        )
       end
     end
   end

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

@@ -1,231 +1,14 @@
 require "nokogiri"
-require_relative "xml_document"
-require_relative "builder/nokogiri"
+require_relative "../xml/nokogiri_adapter"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class NokogiriAdapter < XmlDocument
-        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::XmlAdapter::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|
-              index_hash[object.name] ||= -1
-              curr_index = index_hash[object.name] += 1
-
-              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)
-
-              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,
-            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
+      class NokogiriAdapter < ::Lutaml::Model::Xml::NokogiriAdapter
+        Logger.warn_future_deprication(
+          old: "Lutaml::Model::XmlAdapter::NokogiriAdapter",
+          replacement: "Lutaml::Model::Xml::NokogiriAdapter",
+        )
       end
     end
   end

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

@@ -1,170 +1,20 @@
-require "oga"
-require "moxml/adapter/oga"
-require_relative "xml_document"
-require_relative "oga/document"
-require_relative "oga/element"
-require_relative "builder/oga"
+# require "oga"
+# require "moxml/adapter/oga"
+# require_relative "xml_document"
+# require_relative "oga/document"
+# require_relative "oga/element"
+# require_relative "builder/oga"
+
+require_relative "../xml/oga_adapter"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class OgaAdapter < XmlDocument
-        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|
-              index_hash[object.name] ||= -1
-              curr_index = index_hash[object.name] += 1
-
-              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 && 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
+      class OgaAdapter < ::Lutaml::Model::Xml::OgaAdapter
+        Logger.warn_future_deprication(
+          old: "Lutaml::Model::XmlAdapter::OgaAdapter",
+          replacement: "Lutaml::Model::Xml::OgaAdapter",
+        )
       end
     end
   end