lutaml-model 0.7.1 → 0.7.7

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_deprecation(
+          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/yamls/document.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Yamls
+      class Document
+        def initialize(yamls = [], register: nil)
+          @yamls = yamls
+          @register = register || Lutaml::Model::Config.default_register
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module Yamls
+      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/yamls/mapping_rule.rb

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

data/lib/lutaml/model/yamls/standard_adapter.rb

@@ -0,0 +1,34 @@
+require "yaml"
+require_relative "document"
+
+module Lutaml
+  module Model
+    module Yamls
+      class StandardAdapter < Document
+        FORMAT_SYMBOL = :yaml
+
+        def self.parse(yamls, _options = {})
+          results = []
+
+          yamls.split(/^---\n/).each do |yaml|
+            next if yaml.strip.empty?
+
+            begin
+              results << YAML.safe_load(yaml, aliases: true)
+            rescue Psych::SyntaxError => e
+              warn "Skipping invalid yaml: #{e.message}"
+            end
+          end
+
+          results
+        end
+
+        def to_yamls(*_args)
+          @yamls.map do |yaml|
+            YAML.dump(yaml).strip
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Lutaml
+  module Model
+    module Yamls
+      class Transform < Lutaml::Model::KeyValueTransform
+        def data_to_model(data, format, options = {})
+          mappings = defined_mappings_for(:yamls) || mappings_for(:yaml)
+
+          super(data, format, options.merge(mappings: mappings))
+        end
+
+        def model_to_data(instance, format, options = {})
+          mappings = defined_mappings_for(:yamls) || mappings_for(:yaml)
+
+          super(instance, format, options.merge(mappings: mappings))
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/yamls.rb

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

data/lib/lutaml/model.rb

@@ -2,17 +2,28 @@
 
 require "moxml"
 require_relative "model/uninitialized_class"
+require_relative "model/errors"
+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/global_register"
+require_relative "model/register"
+require_relative "model/format_registry"
+require_relative "model/collection"
+require_relative "model/key_value_document"
+require_relative "model/yaml"
+require_relative "model/yamls"
+require_relative "model/json"
+require_relative "model/jsonl"
+require_relative "model/toml"
+require_relative "model/hash_adapter"
+require_relative "model/xml"
 
 module Lutaml
   module Model

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_type = :nokogiri
   end
 
   let(:large_xml) do
@@ -26,7 +26,6 @@ RSpec.describe "LutaML Model Performance" do
       map_attribute "id", to: :id
       map_element "value", to: :value
       map_element "name", to: :name
-      map_element "value", to: :value
     end
   end
 
@@ -48,12 +47,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_type = :ox
         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_type = :oga
         Deserializer.from_xml(large_xml)
       end
 
@@ -62,7 +61,7 @@ RSpec.describe "LutaML Model Performance" do
 
     thresholds = {
       "Nokogiri Adapter" => 3,
-      "Ox Adapter" => 7,
+      "Ox Adapter" => 6,
       "Oga Adapter" => 3,
     }
 

data/spec/fixtures/xml/advanced_test_schema.xsd

@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:test="http://www.example.com/test" targetNamespace="http://www.example.com/test" elementFormDefault="qualified">
+
+  <!-- Advanced Simple Types -->
+  <xs:simpleType name="StringOrInteger">
+    <xs:union memberTypes="xs:string xs:integer"/>
+  </xs:simpleType>
+
+  <xs:simpleType name="ColorList">
+    <xs:list itemType="xs:string"/>
+  </xs:simpleType>
+
+  <xs:simpleType name="RestrictedString">
+    <xs:restriction base="xs:string">
+      <xs:pattern value="[A-Z][a-z]+"/>
+      <xs:minLength value="2"/>
+      <xs:maxLength value="20"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <!-- Base Complex Types -->
+  <xs:complexType name="BaseType">
+    <xs:sequence>
+      <xs:element name="id" type="xs:integer"/>
+      <xs:element name="name" type="test:RestrictedString"/>
+    </xs:sequence>
+    <xs:attribute name="version" type="xs:string" use="optional"/>
+  </xs:complexType>
+
+  <!-- Extension using complexContent -->
+  <xs:complexType name="ExtendedType">
+    <xs:complexContent>
+      <xs:extension base="test:BaseType">
+        <xs:sequence>
+          <xs:element name="description" type="xs:string"/>
+          <xs:element name="tags" type="test:ColorList"/>
+        </xs:sequence>
+        <xs:attribute name="priority" type="xs:integer" use="required"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <!-- Restriction using complexContent -->
+  <xs:complexType name="RestrictedType">
+    <xs:complexContent>
+      <xs:restriction base="test:BaseType">
+        <xs:sequence>
+          <xs:element name="id" type="xs:positiveInteger"/>
+          <xs:element name="name" type="test:RestrictedString"/>
+        </xs:sequence>
+        <xs:attribute name="version" type="xs:string" fixed="1.0"/>
+      </xs:restriction>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <!-- Mixed Content Type -->
+  <xs:complexType name="MixedContentType" mixed="true">
+    <xs:sequence>
+      <xs:element name="bold" type="xs:string" minOccurs="0"/>
+      <xs:element name="italic" type="xs:string" minOccurs="0"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- Group Definitions -->
+  <xs:group name="CommonElements">
+    <xs:sequence>
+      <xs:element name="created" type="xs:dateTime"/>
+      <xs:element name="modified" type="xs:dateTime"/>
+    </xs:sequence>
+  </xs:group>
+
+  <!-- Attribute Group -->
+  <xs:attributeGroup name="CommonAttributes">
+    <xs:attribute name="id" type="xs:ID" use="required"/>
+    <xs:attribute name="type" type="xs:string" use="optional"/>
+  </xs:attributeGroup>
+
+  <!-- Complex Type with Groups -->
+  <xs:complexType name="GroupedType">
+    <xs:sequence>
+      <xs:group ref="test:CommonElements"/>
+      <xs:element name="content" type="xs:string"/>
+    </xs:sequence>
+    <xs:attributeGroup ref="test:CommonAttributes"/>
+  </xs:complexType>
+
+  <!-- Choice Element -->
+  <xs:complexType name="ChoiceType">
+    <xs:choice minOccurs="1" maxOccurs="unbounded">
+      <xs:element name="text" type="xs:string"/>
+      <xs:element name="number" type="xs:integer"/>
+      <xs:element name="date" type="xs:date"/>
+    </xs:choice>
+  </xs:complexType>
+
+  <!-- All Element -->
+  <xs:complexType name="AllType">
+    <xs:all>
+      <xs:element name="first" type="xs:string"/>
+      <xs:element name="second" type="xs:integer"/>
+      <xs:element name="third" type="xs:boolean"/>
+    </xs:all>
+  </xs:complexType>
+
+  <!-- Root Elements -->
+  <xs:element name="TestDocument">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element name="base" type="test:BaseType"/>
+        <xs:element name="extended" type="test:ExtendedType"/>
+        <xs:element name="restricted" type="test:RestrictedType"/>
+        <xs:element name="mixed" type="test:MixedContentType"/>
+        <xs:element name="grouped" type="test:GroupedType"/>
+        <xs:element name="choice" type="test:ChoiceType"/>
+        <xs:element name="all" type="test:AllType"/>
+      </xs:sequence>
+    </xs:complexType>
+  </xs:element>
+
+  <!-- Alternative Root with Substitution Group -->
+  <xs:element name="AlternativeDocument" substitutionGroup="test:TestDocument">
+    <xs:complexType>
+      <xs:complexContent>
+        <xs:extension base="test:TestDocument">
+          <xs:sequence>
+            <xs:element name="additional" type="xs:string"/>
+          </xs:sequence>
+        </xs:extension>
+      </xs:complexContent>
+    </xs:complexType>
+  </xs:element>
+
+</xs:schema>