lutaml-model 0.7.1 → 0.7.3

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

@@ -1,214 +1,17 @@
-require "ox"
-require_relative "xml_document"
-require_relative "builder/ox"
+# require "ox"
+# require_relative "xml_document"
+# require_relative "builder/ox"
+
+require_relative "../xml/ox_adapter"
 
 module Lutaml
   module Model
     module XmlAdapter
-      class OxAdapter < XmlDocument
-        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::XmlAdapter::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|
-              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 = 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)
-          when Ox::Comment
-            super("comment", {}, [], node.value, parent_document: root_node)
-          when Ox::CData
-            super("#cdata-section", {}, [], node.value, parent_document: root_node)
-          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
-
-            super(
-              node,
-              attributes,
-              parse_children(node, root_node: root_node || self),
-              node.text,
-              parent_document: root_node,
-            )
-          end
-        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
+      class OxAdapter < ::Lutaml::Model::Xml::OxAdapter
+        Logger.warn_future_deprication(
+          old: "Lutaml::Model::XmlAdapter::OxAdapter",
+          replacement: "Lutaml::Model::Xml::OxAdapter",
+        )
       end
     end
   end

data/lib/lutaml/model/yaml/document.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Yaml
+      # Base class for YAML documents
+      class Document < Lutaml::Model::KeyValueDocument; end
+    end
+  end
+end

data/lib/lutaml/model/yaml/mapping.rb

@@ -0,0 +1,19 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module Yaml
+      class Mapping < Lutaml::Model::KeyValueMapping
+        def initialize
+          super(:yaml)
+        end
+
+        def deep_dup
+          self.class.new.tap do |new_mapping|
+            new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/yaml/mapping_rule.rb

@@ -0,0 +1,9 @@
+require_relative "../mapping/key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    module Yaml
+      class MappingRule < Lutaml::Model::KeyValueMappingRule; end
+    end
+  end
+end

data/lib/lutaml/model/{yaml_adapter/standard_yaml_adapter.rb → yaml/standard_adapter.rb}

@@ -1,10 +1,11 @@
 require "yaml"
-require_relative "yaml_document"
+require_relative "document"
 
 module Lutaml
   module Model
-    module YamlAdapter
-      class StandardYamlAdapter < YamlDocument
+    module Yaml
+      class StandardAdapter < Document
+        FORMAT_SYMBOL = :yaml
         PERMITTED_CLASSES_BASE = [Date, Time, DateTime, Symbol, Hash,
                                   Array].freeze
 

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

@@ -0,0 +1,8 @@
+module Lutaml
+  module Model
+    module Yaml
+      class Transform < Lutaml::Model::KeyValueTransform
+      end
+    end
+  end
+end

data/lib/lutaml/model/yaml.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Yaml
+    end
+  end
+end
+
+require_relative "yaml/standard_adapter"
+require_relative "yaml/document"
+require_relative "yaml/mapping"
+require_relative "yaml/mapping_rule"
+require_relative "yaml/transform"
+
+Lutaml::Model::FormatRegistry.register(
+  :yaml,
+  mapping_class: Lutaml::Model::Yaml::Mapping,
+  adapter_class: Lutaml::Model::Yaml::StandardAdapter,
+  transformer: Lutaml::Model::Yaml::Transform,
+)

data/lib/lutaml/model.rb

@@ -2,17 +2,23 @@
 
 require "moxml"
 require_relative "model/uninitialized_class"
+require_relative "model/services"
 require_relative "model/version"
-require_relative "model/loggable"
 require_relative "model/type"
 require_relative "model/utils"
 require_relative "model/serializable"
-require_relative "model/json_adapter/standard_json_adapter"
-require_relative "model/yaml_adapter/standard_yaml_adapter"
 require_relative "model/xml_adapter"
-require_relative "model/toml_adapter"
 require_relative "model/error"
 require_relative "model/constants"
+require_relative "model/config"
+require_relative "model/format_registry"
+
+require_relative "model/key_value_document"
+require_relative "model/yaml"
+require_relative "model/json"
+require_relative "model/toml"
+require_relative "model/hash"
+require_relative "model/xml"
 
 module Lutaml
   module Model
@@ -24,5 +30,34 @@ module Lutaml
 
     class BaseModel < Serializable
     end
+
+    # Register default adapters
+    # Lutaml::Model::FormatRegistry.register(
+    #   :json,
+    #   mapping_class: KeyValueMapping,
+    #   adapter_class: JsonAdapter::StandardJsonAdapter,
+    #   transformer: Lutaml::Model::KeyValueTransform,
+    # )
+
+    # Lutaml::Model::FormatRegistry.register(
+    #   :yaml,
+    #   mapping_class: KeyValueMapping,
+    #   adapter_class: YamlAdapter::StandardYamlAdapter,
+    #   transformer: Lutaml::Model::KeyValueTransform,
+    # )
+
+    # Lutaml::Model::FormatRegistry.register(
+    #   :toml,
+    #   mapping_class: KeyValueMapping,
+    #   adapter_class: nil,
+    #   transformer: Lutaml::Model::KeyValueTransform,
+    # )
+
+    # Lutaml::Model::FormatRegistry.register(
+    #   :xml,
+    #   mapping_class: XmlMapping,
+    #   adapter_class: nil,
+    #   transformer: Lutaml::Model::XmlTransform,
+    # )
   end
 end

data/lutaml-model.gemspec

@@ -30,10 +30,6 @@ Gem::Specification.new do |spec|
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
 
-  # TODO: remove once https://github.com/Shopify/liquid/issues/1772 is fixed
-  # needed for liquid with ruby 3.4
-  spec.add_dependency "base64"
-  spec.add_dependency "liquid", "~> 5"
   spec.add_dependency "moxml", ">= 0.1.2"
   spec.add_dependency "thor"
   spec.metadata["rubygems_mfa_required"] = "true"

data/spec/benchmarks/xml_parsing_benchmark_spec.rb

@@ -1,11 +1,11 @@
 require "benchmark"
 require "benchmark/ips"
 require "lutaml/model"
-require "lutaml/model/xml_adapter/oga_adapter"
+require "lutaml/model/xml/oga_adapter"
 
 RSpec.describe "LutaML Model Performance" do
   after do
-    Lutaml::Model::Config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+    Lutaml::Model::Config.xml_adapter = Lutaml::Model::Xml::NokogiriAdapter
   end
 
   let(:large_xml) do
@@ -48,12 +48,12 @@ RSpec.describe "LutaML Model Performance" do
       end
 
       x.report("Ox Adapter") do
-        Lutaml::Model::Config.xml_adapter = Lutaml::Model::XmlAdapter::OxAdapter
+        Lutaml::Model::Config.xml_adapter = Lutaml::Model::Xml::OxAdapter
         Deserializer.from_xml(large_xml)
       end
 
       x.report("Oga Adapter") do
-        Lutaml::Model::Config.xml_adapter = Lutaml::Model::XmlAdapter::OgaAdapter
+        Lutaml::Model::Config.xml_adapter = Lutaml::Model::Xml::OgaAdapter
         Deserializer.from_xml(large_xml)
       end
 

data/spec/lutaml/model/cdata_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "lutaml/model"
-require "lutaml/model/xml_adapter/nokogiri_adapter"
-require "lutaml/model/xml_adapter/ox_adapter"
+require "lutaml/model/xml/nokogiri_adapter"
+require "lutaml/model/xml/ox_adapter"
 
 module CDATA
   class Beta < Lutaml::Model::Serializable
@@ -350,7 +350,7 @@ RSpec.describe "CDATA" do
           instance = parent_mapper.from_xml(input_xml)
           result_xml = parent_mapper.to_xml(instance)
 
-          expected_output = adapter_class == Lutaml::Model::XmlAdapter::OxAdapter ? expected_ox_xml : expected_nokogiri_xml
+          expected_output = adapter_class == Lutaml::Model::Xml::OxAdapter ? expected_ox_xml : expected_nokogiri_xml
 
           expect(result_xml.strip).to eq(expected_output.strip)
         end
@@ -439,7 +439,7 @@ RSpec.describe "CDATA" do
 
           # due to the difference in capturing
           # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+          if adapter_class == Lutaml::Model::Xml::OxAdapter
             expected_xml = expected_ox_xml
           end
 
@@ -496,7 +496,7 @@ RSpec.describe "CDATA" do
 
           # due to the difference in capturing
           # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+          if adapter_class == Lutaml::Model::Xml::OxAdapter
             expected_xml = expected_ox_xml
           end
 
@@ -509,11 +509,11 @@ RSpec.describe "CDATA" do
     end
   end
 
-  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  describe Lutaml::Model::Xml::NokogiriAdapter do
     it_behaves_like "cdata behavior", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OxAdapter do
+  describe Lutaml::Model::Xml::OxAdapter do
     it_behaves_like "cdata behavior", described_class
   end
 end