lutaml-model 0.6.7 → 0.7.2

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 = options[:mapper_class] || element.class
-          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

@@ -1,17 +1,24 @@
 # frozen_string_literal: true
 
 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
@@ -23,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
 
@@ -61,9 +61,9 @@ RSpec.describe "LutaML Model Performance" do
     end
 
     thresholds = {
-      "Nokogiri Adapter" => 4,
-      "Ox Adapter" => 10,
-      "Oga Adapter" => 4,
+      "Nokogiri Adapter" => 3,
+      "Ox Adapter" => 7,
+      "Oga Adapter" => 3,
     }
 
     report.entries.each do |entry|

data/spec/fixtures/person.rb

@@ -17,11 +17,11 @@ class Person < Lutaml::Model::Serializable
     map_element "FirstName",
                 to: :first_name,
                 namespace: "http://example.com/nsp1",
-                prefix: "nsp1"
+                prefix: "nsp1", render_empty: :omit
     map_element "LastName",
                 to: :last_name,
                 namespace: "http://example.com/nsp1",
-                prefix: "nsp1"
+                prefix: "nsp1", render_empty: :as_blank
     map_element "Age", to: :age
     map_element "Height", to: :height
     map_element "Birthdate", to: :birthdate
@@ -31,9 +31,9 @@ class Person < Lutaml::Model::Serializable
   end
 
   json do
-    map "firstName", to: :first_name
-    map "lastName", to: :last_name
-    map "age", to: :age
+    map "firstName", to: :first_name, render_empty: :omit
+    map "lastName", to: :last_name, render_empty: :as_empty
+    map "age", to: :age, render_empty: :as_nil
     map "height", to: :height
     map "birthdate", to: :birthdate
     map "lastLogin", to: :last_login

data/spec/lutaml/model/attribute_spec.rb

@@ -136,7 +136,9 @@ RSpec.describe Lutaml::Model::Attribute do
     context "when default is not set" do
       let(:attribute) { described_class.new("name", :string) }
 
-      it { expect(attribute.default).to be_nil }
+      it "returns uninitialized" do
+        expect(attribute.default).to be(Lutaml::Model::UninitializedClass.instance)
+      end
     end
 
     context "when default is set as a proc" do
@@ -165,4 +167,38 @@ RSpec.describe Lutaml::Model::Attribute do
       end
     end
   end
+
+  describe "#deep_dup" do
+    let(:duplicate_attribute) { Lutaml::Model::Utils.deep_dup(attribute) }
+
+    context "when deep_dup method is not defined and instance is deep_duplicated" do
+      let(:attribute) { described_class.new("name", :string) }
+
+      before do
+        described_class.alias_method :orig_deep_dup, :deep_dup
+        described_class.undef_method :deep_dup
+      end
+
+      after do
+        described_class.alias_method :deep_dup, :orig_deep_dup
+        attribute.options.delete(:foo)
+      end
+
+      it "confirms that options values are linked of original and duplicate instances" do
+        duplicate_attribute
+        attribute.options[:foo] = "bar"
+        expect(duplicate_attribute.options).to include(:foo)
+      end
+    end
+
+    context "when deep_dup method is defined and instance is deep_duplicated" do
+      let(:attribute) { described_class.new("name", :string) }
+
+      it "confirms that options values are not linked of original and duplicate instances" do
+        duplicate_attribute
+        attribute.options[:foo] = "bar"
+        expect(duplicate_attribute.options).not_to include(:foo)
+      end
+    end
+  end
 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
@@ -117,8 +117,8 @@ module CDATA
 
     def child_from_xml(model, value)
       model.child_mapper ||= CustomModelChild.new
-      model.child_mapper.street = value.first.find_child_by_name("street").text
-      model.child_mapper.city = value.first.find_child_by_name("city").text
+      model.child_mapper.street = value.first.find_child_by_name("street").cdata
+      model.child_mapper.city = value.first.find_child_by_name("city").cdata
     end
   end
 
@@ -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

data/spec/lutaml/model/collection_spec.rb

@@ -54,6 +54,16 @@ module CollectionTests
       doc.add_element(parent, "<city>#{model.city}</city>")
     end
   end
+
+  class ReturnNilTest < Lutaml::Model::Serializable
+    attribute :default_items, :string, collection: true
+    attribute :regular_items, :string, collection: true, initialize_empty: true
+
+    yaml do
+      map "default_items", to: :default_items
+      map "regular_items", to: :regular_items, render_default: true, render_empty: true
+    end
+  end
 end
 
 RSpec.describe CollectionTests do
@@ -95,8 +105,8 @@ RSpec.describe CollectionTests do
   it "initializes with default values" do
     default_model = CollectionTests::Kiln.new
     expect(default_model.brand).to be_nil
-    expect(default_model.pots).to eq([])
-    expect(default_model.temperatures).to eq([])
+    expect(default_model.pots).to be_nil
+    expect(default_model.temperatures).to be_nil
     expect(default_model.operators).to eq(["Default Operator"])
     expect(default_model.sensors).to eq(["Default Sensor"])
   end
@@ -280,4 +290,42 @@ RSpec.describe CollectionTests do
       end.not_to raise_error
     end
   end
+
+  context "when using initialize_empty option with collections" do
+    let(:parsed) { CollectionTests::ReturnNilTest.from_yaml(yaml) }
+    let(:model) { CollectionTests::ReturnNilTest.new }
+
+    let(:yaml) do
+      <<~YAML
+        ---
+        regular_items: ~
+      YAML
+    end
+
+    it "sets nil value when reading from YAML with nil value" do
+      expect(parsed.default_items).to be_nil
+      expect(parsed.regular_items).to be_nil
+    end
+
+    it "initializes with empty array when initialize_empty is true" do
+      expect(model.regular_items).to eq([])
+    end
+
+    it "preserves initialize_empty behavior when serializing and deserializing" do
+      expected_yaml = <<~YAML
+        ---
+        regular_items: []
+      YAML
+
+      expect(model.to_yaml).to eq(expected_yaml)
+    end
+
+    it "raises StandardError for initialize_empty without collection" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :invalid_range, :string, initialize_empty: true
+        end
+      end.to raise_error(StandardError, /Invalid option `initialize_empty` given without `collection: true` option/)
+    end
+  end
 end