lutaml-model 0.6.7 → 0.7.1

data/lib/lutaml/model/uninitialized_class.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module Lutaml
+  module Model
+    class UninitializedClass
+      include Singleton
+
+      def to_s
+        self
+      end
+
+      def inspect
+        "unititialized"
+      end
+
+      def uninitialized?
+        true
+      end
+
+      def match?(_args)
+        false
+      end
+
+      def include?(_args)
+        false
+      end
+
+      def gsub(_, _)
+        self
+      end
+
+      def to_yaml
+        nil
+      end
+
+      def to_f
+        self
+      end
+
+      def size
+        0
+      end
+
+      def encoding
+        # same as default encoding for string
+        "".encoding
+      end
+
+      def method_missing(method, *_args, &_block)
+        if method.end_with?("?")
+          false
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        method_name.end_with?("?")
+      end
+    end
+  end
+end

data/lib/lutaml/model/utils.rb

@@ -34,6 +34,16 @@ module Lutaml
             .downcase
         end
 
+        def initialized?(value)
+          return true unless value.respond_to?(:initialized?)
+
+          value.initialized?
+        end
+
+        def uninitialized?(value)
+          !initialized?(value)
+        end
+
         def present?(value)
           !blank?(value)
         end
@@ -49,6 +59,10 @@ module Lutaml
           collection.empty?
         end
 
+        def empty?(value)
+          value.respond_to?(:empty?) ? value.empty? : false
+        end
+
         def add_method_if_not_defined(klass, method_name, &block)
           unless klass.method_defined?(method_name)
             klass.class_eval do

data/lib/lutaml/model/validation.rb

@@ -14,6 +14,7 @@ module Lutaml
           rescue Lutaml::Model::InvalidValueError,
                  Lutaml::Model::CollectionCountOutOfRangeError,
                  Lutaml::Model::CollectionTrueMissingError,
+                 Lutaml::Model::PolymorphicError,
                  PatternNotMatchedError => e
             errors << e
           end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.6.7"
+    VERSION = "0.7.1"
   end
 end

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

@@ -53,7 +53,7 @@ module Lutaml
         end
 
         def build_ordered_element(xml, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
+          mapper_class = determine_mapper_class(element, options)
           xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 

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

@@ -113,7 +113,7 @@ module Lutaml
         private
 
         def build_ordered_element(builder, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
+          mapper_class = determine_mapper_class(element, options)
           xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 

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

@@ -46,7 +46,7 @@ module Lutaml
         private
 
         def build_ordered_element(builder, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
+          mapper_class = determine_mapper_class(element, options)
           xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 

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

@@ -158,7 +158,7 @@ module Lutaml
             value = transform_method.call(value)
           end
 
-          if value.is_a?(Array)
+          if value.is_a?(Array) && !Utils.empty_collection?(value)
             value.each do |item|
               add_to_xml(xml, element, prefix, item, options)
             end
@@ -168,12 +168,18 @@ module Lutaml
 
           return if !render_element?(rule, element, value)
 
+          value = rule.render_value_for(value)
+
           if value && (attribute&.type&.<= Lutaml::Model::Serialize)
             handle_nested_elements(
               xml,
               value,
               options.merge({ rule: rule, attribute: attribute }),
             )
+          elsif value.nil?
+            xml.create_and_add_element(rule.name, attributes: { "xsi:nil" => true })
+          elsif Utils.empty?(value)
+            xml.create_and_add_element(rule.name)
           elsif rule.raw_mapping?
             xml.add_xml_fragment(xml, value)
           elsif rule.prefix_set?
@@ -205,19 +211,12 @@ module Lutaml
         end
 
         def build_unordered_element(xml, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
+          mapper_class = determine_mapper_class(element, options)
           xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
-          attributes = options[:xml_attributes] ||= {}
-          attributes = build_attributes(element,
-                                        xml_mapping, options).merge(attributes)&.compact
-
-          prefix = if options.key?(:namespace_prefix)
-                     options[:namespace_prefix]
-                   elsif xml_mapping.namespace_prefix
-                     xml_mapping.namespace_prefix
-                   end
+          attributes = build_element_attributes(element, xml_mapping, options)
+          prefix = determine_namespace_prefix(options, xml_mapping)
 
           prefixed_xml = xml.add_namespace_prefix(prefix)
           tag_name = options[:tag_name] || xml_mapping.root_element
@@ -234,6 +233,7 @@ module Lutaml
             end
 
             mappings = xml_mapping.elements + [xml_mapping.raw_mapping].compact
+
             mappings.each do |element_rule|
               attribute_def = attribute_definition_for(element, element_rule,
                                                        mapper_class: mapper_class)
@@ -241,7 +241,7 @@ module Lutaml
               if attribute_def
                 value = attribute_value_for(element, element_rule)
 
-                next if value.nil? && !element_rule.render_nil?
+                next if !element_rule.render?(value, element)
 
                 value = [value] if attribute_def.collection? && !value.is_a?(Array)
               end
@@ -271,6 +271,8 @@ module Lutaml
             text = content_rule.serialize(element)
             text = text.join if text.is_a?(Array)
 
+            return unless content_rule.render?(text, element)
+
             xml.add_text(xml, text, cdata: content_rule.cdata)
           end
         end
@@ -289,11 +291,7 @@ module Lutaml
         end
 
         def render_element?(rule, element, value)
-          render_default?(rule, element) && render_value?(rule, value)
-        end
-
-        def render_value?(rule, value)
-          rule.attribute? || rule.render_nil? || !value.nil?
+          rule.render?(value, element)
         end
 
         def render_default?(rule, element)
@@ -433,6 +431,29 @@ module Lutaml
         def cdata
           @root.cdata
         end
+
+        private
+
+        def determine_mapper_class(element, options)
+          if options[:mapper_class] && element.is_a?(options[:mapper_class])
+            element.class
+          else
+            options[:mapper_class] || element.class
+          end
+        end
+
+        def determine_namespace_prefix(options, mapping)
+          return options[:namespace_prefix] if options.key?(:namespace_prefix)
+
+          mapping.namespace_prefix
+        end
+
+        def build_element_attributes(element, mapping, options)
+          xml_attributes = options[:xml_attributes] ||= {}
+          attributes = build_attributes(element, mapping, options)
+
+          attributes.merge(xml_attributes)&.compact
+        end
       end
     end
   end

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

@@ -127,9 +127,17 @@ module Lutaml
         end
 
         def text
+          return @text if children.empty?
           return text_children.map(&:text) if children.count > 1
 
-          @text
+          text_children.map(&:text).join
+        end
+
+        def cdata
+          return @text if children.empty?
+          return cdata_children.map(&:text) if children.count > 1
+
+          cdata_children.map(&:text).join
         end
 
         def cdata_children
@@ -140,6 +148,10 @@ module Lutaml
           find_children_by_name("text")
         end
 
+        def [](name)
+          find_attribute_value(name) || find_children_by_name(name)
+        end
+
         def find_attribute_value(attribute_name)
           if attribute_name.is_a?(Array)
             attributes.values.find do |attr|
@@ -164,15 +176,13 @@ module Lutaml
           find_children_by_name(name).first
         end
 
-        def cdata
-          return cdata_children.map(&:text) if children.count > 1
-
-          @text
-        end
-
         def to_h
           document.to_h
         end
+
+        def nil_element?
+          find_attribute_value("xsi:nil") == "true"
+        end
       end
     end
   end

data/lib/lutaml/model.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "moxml"
+require_relative "model/uninitialized_class"
 require_relative "model/version"
 require_relative "model/loggable"
 require_relative "model/type"

data/spec/benchmarks/xml_parsing_benchmark_spec.rb

@@ -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

@@ -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
 

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

data/spec/lutaml/model/comparable_model_spec.rb

@@ -19,6 +19,11 @@ class ComparableCeramicCollection < Lutaml::Model::Serializable
   attribute :featured_piece, ComparableCeramic # This creates a two-level nesting
 end
 
+class RecursiveNode < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :next_node, RecursiveNode
+end
+
 RSpec.describe Lutaml::Model::ComparableModel do
   describe "comparisons" do
     context "with simple types (Glaze)" do
@@ -68,38 +73,98 @@ RSpec.describe Lutaml::Model::ComparableModel do
     end
 
     context "with deeply nested Serializable objects (CeramicCollection)" do
+      let(:first_collection) do
+        ComparableCeramicCollection.new(
+          name: "Blue Collection",
+          featured_piece: ComparableCeramic.new(
+            type: "Bowl",
+            glaze: ComparableGlaze.new(
+              color: "Blue",
+              temperature: 1200,
+              food_safe: true,
+            ),
+          ),
+        )
+      end
+
+      let(:second_collection) do
+        ComparableCeramicCollection.new(
+          name: "Blue Collection",
+          featured_piece: ComparableCeramic.new(
+            type: "Bowl",
+            glaze: ComparableGlaze.new(
+              color: "Blue",
+              temperature: 1200,
+              food_safe: true,
+            ),
+          ),
+        )
+      end
+
       it "compares equal objects with two levels of nesting" do
         # This test compares CeramicCollection objects that contain Ceramic objects,
         # which in turn contain Glaze objects - a two-level deep nesting
-        glaze1 = ComparableGlaze.new(color: "Blue", temperature: 1200,
-                                     food_safe: true)
-        glaze2 = ComparableGlaze.new(color: "Blue", temperature: 1200,
-                                     food_safe: true)
-        ceramic1 = ComparableCeramic.new(type: "Bowl", glaze: glaze1)
-        ceramic2 = ComparableCeramic.new(type: "Bowl", glaze: glaze2)
-        collection1 = ComparableCeramicCollection.new(name: "Blue Collection",
-                                                      featured_piece: ceramic1)
-        collection2 = ComparableCeramicCollection.new(name: "Blue Collection",
-                                                      featured_piece: ceramic2)
-        expect(collection1).to eq(collection2)
-        expect(collection1.hash).to eq(collection2.hash)
+        expect(first_collection).to eq(second_collection)
       end
 
-      it "compares unequal objects with two levels of nesting" do
-        # This test compares CeramicCollection objects that are different at every level:
-        # the collection name, the ceramic type, and the glaze properties
-        glaze1 = ComparableGlaze.new(color: "Blue", temperature: 1200,
-                                     food_safe: true)
-        glaze2 = ComparableGlaze.new(color: "Red", temperature: 1000,
-                                     food_safe: false)
-        ceramic1 = ComparableCeramic.new(type: "Bowl", glaze: glaze1)
-        ceramic2 = ComparableCeramic.new(type: "Plate", glaze: glaze2)
-        collection1 = ComparableCeramicCollection.new(name: "Blue Collection",
-                                                      featured_piece: ceramic1)
-        collection2 = ComparableCeramicCollection.new(name: "Red Collection",
-                                                      featured_piece: ceramic2)
-        expect(collection1).not_to eq(collection2)
-        expect(collection1.hash).not_to eq(collection2.hash)
+      it "generates same hash for objects with two levels of nesting" do
+        expect(first_collection.hash).to eq(second_collection.hash)
+      end
+
+      context "with deeply nested objects that are not equal" do
+        before do
+          second_collection.name = "Red Collection"
+          second_collection.featured_piece.type = "Plate"
+          second_collection.featured_piece.glaze.color = "Red"
+        end
+
+        it "compares unequal objects with two levels of nesting" do
+          # This test compares CeramicCollection objects that are different at every level:
+          # the collection name, the ceramic type, and the glaze properties
+          expect(first_collection).not_to eq(second_collection)
+        end
+
+        it "generates different hashes for objects with two levels of nesting" do
+          expect(first_collection.hash).not_to eq(second_collection.hash)
+        end
+      end
+    end
+
+    context "with recursive relationships" do
+      let(:first_recursive_node) do
+        node1 = RecursiveNode.new(name: "A")
+        node2 = RecursiveNode.new(name: "B", next_node: node1)
+        node1.next_node = node2
+        node1
+      end
+
+      let(:second_recursive_node) do
+        node1 = RecursiveNode.new(name: "A")
+        node2 = RecursiveNode.new(name: "B", next_node: node1)
+        node1.next_node = node2
+        node1
+      end
+
+      describe ".eql?" do
+        it "compares equal objects" do
+          expect(first_recursive_node).to eq(second_recursive_node)
+        end
+
+        it "compares unequal objects" do
+          second_recursive_node.name = "X"
+          expect(first_recursive_node).not_to eq(second_recursive_node)
+        end
+      end
+
+      describe ".hash" do
+        it "returns the same hash for equal objects" do
+          expect(first_recursive_node.hash).to eq(second_recursive_node.hash)
+        end
+
+        it "returns different hashes for unequal objects" do
+          second_recursive_node.name = "X"
+          expect(first_recursive_node.hash).not_to eq(second_recursive_node.hash)
+        end
       end
     end
   end

data/spec/lutaml/model/defaults_spec.rb

@@ -143,7 +143,7 @@ RSpec.describe DefaultsSpec::Glaze do
       expect(default_model.temperature).to eq(1050)
       expect(default_model.firing_time).to eq(60)
       expect(default_model.balance).to eq(BigDecimal("0.0"))
-      expect(default_model.tags).to eq([])
+      expect(default_model.tags).to be_nil
       expect(default_model.properties).to eq({ food_safe: true })
       expect(default_model.status).to eq("active")
       expect(default_model.batch_number).to eq(0)

data/spec/lutaml/model/enum_spec.rb

@@ -5,7 +5,7 @@ module EnumSpec
   class WithEnum < Lutaml::Model::Serializable
     attribute :without_enum, :string
     attribute :single_value, :string, values: %w[user admin super_admin]
-    attribute :multi_value, :string, values: %w[singular dual plural], collection: true
+    attribute :multi_value, :string, values: %w[singular dual plural], collection: true, initialize_empty: true
   end
 end