lutaml-model 0.6.7 → 0.7.2

data/spec/lutaml/model/render_nil_spec.rb

@@ -21,35 +21,80 @@ class RenderNil < Lutaml::Model::Serializable
   attribute :render_nil_nested, RenderNilNested
 
   json do
-    map "name", to: :name, render_nil: true
-    map "clay_type", to: :clay_type, render_nil: true
-    map "glaze", to: :glaze, render_nil: true
-    map "dimensions", to: :dimensions, render_nil: false
+    map "name", to: :name, render_nil: true, render_empty: true
+    map "clay_type", to: :clay_type, render_nil: true, render_empty: true
+    map "glaze", to: :glaze, render_nil: true, render_empty: true
+    map "dimensions", to: :dimensions, render_empty: false
   end
 
   xml do
     root "render_nil"
-    map_element "name", to: :name, render_nil: true
-    map_element "clay_type", to: :clay_type, render_nil: false
-    map_element "glaze", to: :glaze, render_nil: true
+    map_element "name", to: :name, render_nil: true, render_empty: true
+    map_element "clay_type", to: :clay_type, render_nil: false, render_empty: true
+    map_element "glaze", to: :glaze, render_nil: true, render_empty: true
     map_element "render_nil_nested", to: :render_nil_nested, render_nil: true,
                                      render_default: true
-    map_element "dimensions", to: :dimensions, render_nil: false
+    map_element "dimensions", to: :dimensions, render_empty: false
   end
 
   yaml do
-    map "name", to: :name, render_nil: true
-    map "clay_type", to: :clay_type, render_nil: false
-    map "glaze", to: :glaze, render_nil: true
-    map "dimensions", to: :dimensions, render_nil: false
+    map "name", to: :name, render_nil: true, render_empty: true
+    map "clay_type", to: :clay_type, render_nil: false, render_empty: true
+    map "glaze", to: :glaze, render_nil: true, render_empty: true
+    map "dimensions", to: :dimensions, render_empty: false
     map "render_nil_nested", to: :render_nil_nested, render_nil: false
   end
 
   toml do
-    map "name", to: :name, render_nil: true
-    map "clay_type", to: :clay_type, render_nil: false
-    map "glaze", to: :glaze, render_nil: true
-    map "dimensions", to: :dimensions, render_nil: false
+    map "name", to: :name, render_nil: :empty, render_empty: true
+    map "clay_type", to: :clay_type, render_nil: false, render_empty: true
+    map "glaze", to: :glaze, render_nil: false, render_empty: true
+    map "dimensions", to: :dimensions, render_empty: false
+  end
+end
+
+module RenderNilSpec
+  class OmitNilModel < Lutaml::Model::Serializable
+    attribute :items, :string, collection: true
+
+    xml do
+      root "omit-nil-model"
+      map_element "items", to: :items, render_nil: :omit
+    end
+
+    key_value do
+      map "items", to: :items, render_nil: :omit
+    end
+  end
+
+  class ExplicitNilModel < Lutaml::Model::Serializable
+    attribute :items, :string, collection: true
+
+    xml do
+      root "explicit-nil-model"
+      map_element "items", to: :items, render_nil: :as_nil
+    end
+
+    yaml do
+      map "items", to: :items, render_nil: :as_nil
+    end
+  end
+
+  class AsBlankNilModel < Lutaml::Model::Serializable
+    attribute :items, :string, collection: true
+
+    xml do
+      root "omit-nil-model"
+      map_element "items", to: :items, render_nil: :as_blank
+    end
+  end
+
+  class AsEmptyNilModel < Lutaml::Model::Serializable
+    attribute :items, :string, collection: true
+
+    yaml do
+      map "items", to: :items, render_nil: :as_empty
+    end
   end
 end
 
@@ -82,14 +127,14 @@ RSpec.describe RenderNil do
     expect(pottery.name).to be_nil
     expect(pottery.clay_type).to be_nil
     expect(pottery.glaze).to be_nil
-    expect(pottery.dimensions).to eq([])
+    expect(pottery.dimensions).to be_nil
   end
 
   it "serializes to XML with render_nil option" do
     expected_xml = <<~XML
       <render_nil>
-        <name/>
-        <glaze/>
+        <name xsi:nil="true"/>
+        <glaze xsi:nil="true"/>
         <render_nil_nested/>
       </render_nil>
     XML
@@ -100,8 +145,8 @@ RSpec.describe RenderNil do
   it "deserializes from XML with render_nil option" do
     xml = <<~XML
       <render_nil>
-        <name/>
-        <glaze/>
+        <name xsi:nil="true" />
+        <glaze xsi:nil="true" />
       </render_nil>
     XML
 
@@ -148,7 +193,7 @@ RSpec.describe RenderNil do
       }
     end
 
-    it "does not tread empty string as nil" do
+    it "does not treat empty string as nil" do
       expected_yaml = <<~YAML
         ---
         name: ''
@@ -165,4 +210,143 @@ RSpec.describe RenderNil do
       expect(generated_yaml).to eq(expected_yaml.strip)
     end
   end
+
+  describe "render_nil option" do
+    context "when :omit" do
+      let(:model) { RenderNilSpec::OmitNilModel.new(items: nil) }
+
+      describe "YAML" do
+        let(:parsed) do
+          RenderNilSpec::OmitNilModel.from_yaml(yaml)
+        end
+
+        let(:yaml) do
+          <<~YAML
+            ---
+            items:
+          YAML
+        end
+
+        it "omits nil collections while deserialize" do
+          expect(model.items).to be_nil
+        end
+
+        it "omits nil collections" do
+          expect(parsed.to_yaml.strip).to eq("--- {}")
+        end
+      end
+
+      describe "XML" do
+        let(:parsed) { RenderNilSpec::OmitNilModel.from_xml(xml) }
+
+        let(:xml) do
+          <<~XML
+            <omit-nil-model/>
+          XML
+        end
+
+        it "omits nil collection" do
+          expect(model.to_xml).not_to include("<items")
+        end
+
+        it "omits nil collections while deserialize" do
+          expect(parsed.items).to be_nil
+        end
+      end
+    end
+
+    context "when :as_nil" do
+      let(:model) { RenderNilSpec::ExplicitNilModel.new(items: nil) }
+
+      describe "YAML" do
+        let(:yaml) do
+          <<~YAML
+            ---
+            items:
+          YAML
+        end
+
+        let(:parsed) do
+          RenderNilSpec::ExplicitNilModel.from_yaml(yaml)
+        end
+
+        it "renders explicit nil" do
+          expect(model.to_yaml).to include("items:")
+        end
+
+        it "sets nil values while deserialize" do
+          expect(parsed.items).to be_nil
+        end
+      end
+
+      describe "XML" do
+        let(:xml) do
+          <<~XML
+            <explicit-nil-model>
+              <items xsi:nil="true"/>
+            </explicit-nil-model>
+          XML
+        end
+
+        let(:parsed) do
+          RenderNilSpec::ExplicitNilModel.from_xml(xml)
+        end
+
+        it "renders explicit nil" do
+          expect(model.to_xml).to include('<items xsi:nil="true"/>')
+        end
+
+        it "sets nil values while deserialize" do
+          expect(parsed.items).to be_nil
+        end
+      end
+    end
+
+    context "when :as_blank" do
+      let(:model) { RenderNilSpec::AsBlankNilModel.new(items: nil) }
+
+      let(:parsed) do
+        RenderNilSpec::AsBlankNilModel.from_xml(xml)
+      end
+
+      let(:xml) do
+        <<~XML
+          <explicit-nil-model>
+            <items/>
+          </explicit-nil-model>
+        XML
+      end
+
+      it "creates blank element from nil collections" do
+        expect(model.to_xml).to include("<items/>")
+      end
+
+      it "sets blank values while deserialize" do
+        expect(parsed.items).to eq([])
+      end
+    end
+
+    context "when :as_empty" do
+      let(:model) { RenderNilSpec::AsEmptyNilModel.new(items: nil) }
+
+      let(:parsed) do
+        RenderNilSpec::AsEmptyNilModel.from_yaml(yaml)
+      end
+
+      let(:yaml) do
+        <<~YAML
+          ---
+          items:
+        YAML
+      end
+
+      it "creates key and empty collection" do
+        expect(model.to_yaml).to include("items: []")
+      end
+
+      it "sets nil value while deserialize" do
+        expect(parsed.items).to be_nil
+      end
+    end
+  end
 end

data/spec/lutaml/model/root_mappings_spec.rb

@@ -283,15 +283,15 @@ RSpec.describe "RootMapping" do
     end
   end
 
-  describe Lutaml::Model::YamlAdapter::StandardYamlAdapter do
+  describe Lutaml::Model::Yaml::StandardAdapter do
     it_behaves_like "having root mappings", :yaml
   end
 
-  describe Lutaml::Model::JsonAdapter::StandardJsonAdapter do
+  describe Lutaml::Model::Json::StandardAdapter do
     it_behaves_like "having root mappings", :json
   end
 
-  describe Lutaml::Model::TomlAdapter::TomlRbAdapter do
+  describe Lutaml::Model::Toml::TomlRbAdapter do
     it_behaves_like "having root mappings", :toml
   end
 end

data/spec/lutaml/model/schema/xml_compiler_spec.rb

@@ -471,7 +471,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           Lutaml::Xsd::SimpleContent.new.tap do |ct|
             ct.extension = Lutaml::Xsd::ExtensionSimpleContent.new(base: "test_extension")
             ct.element_order = [
-              Lutaml::Model::XmlAdapter::Element.new("Element", "extension"),
+              Lutaml::Model::Xml::Element.new("Element", "extension"),
             ]
           end
         end
@@ -488,7 +488,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           Lutaml::Xsd::SimpleContent.new.tap do |ct|
             ct.restriction = Lutaml::Xsd::RestrictionSimpleContent.new(base: "test_restriction")
             ct.element_order = [
-              Lutaml::Model::XmlAdapter::Element.new("Element", "restriction"),
+              Lutaml::Model::Xml::Element.new("Element", "restriction"),
             ]
           end
         end
@@ -870,7 +870,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             element.min_occurs = 0
             element.max_occurs = 1
             element.complex_type = Lutaml::Xsd::ComplexType.new(name: "test_complex_type")
-            element.element_order = [Lutaml::Model::XmlAdapter::Element.new("Element", "complex_type")]
+            element.element_order = [Lutaml::Model::Xml::Element.new("Element", "complex_type")]
           end
         end
 
@@ -910,7 +910,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             element.type = "test_type"
             element.name = "test_name"
             element.complex_type = Lutaml::Xsd::ComplexType.new(name: "test_complex_type")
-            element.element_order = [Lutaml::Model::XmlAdapter::Element.new("Element", "complex_type")]
+            element.element_order = [Lutaml::Model::Xml::Element.new("Element", "complex_type")]
           end
         end
 
@@ -1143,7 +1143,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         it "raises an error when element_order contains elements that isn't an attribute of the instance" do
-          element.element_order << Lutaml::Model::XmlAdapter::Element.new("Element", "test_element")
+          element.element_order << Lutaml::Model::Xml::Element.new("Element", "test_element")
           expect { resolved_element_order }.to raise_error(NoMethodError)
         end
 
@@ -1915,7 +1915,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
 end
 
 def create_pattern_mapping(array)
-  array.map { |type, text| Lutaml::Model::XmlAdapter::Element.new(type, text) }
+  array.map { |type, text| Lutaml::Model::Xml::Element.new(type, text) }
 end
 
 def to_mapping_hash(content)

data/spec/lutaml/model/serializable_spec.rb

@@ -96,6 +96,48 @@ module SerializeableSpec
                                         }
     end
   end
+
+  ### Single option serialization
+
+  class SingleOptionModel < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :age, :integer
+    attribute :phone, :string
+    attribute :address, :string
+
+    json do
+      map "name", to: :name
+      map "age", to: :age
+      map "phone", to: :phone, with: { to: :phone_to_json }
+      map "address", to: :address, with: { from: :address_from_json }
+    end
+
+    xml do
+      root "person"
+      map_element "name", to: :name
+      map_element "age", to: :age
+      map_element "phone", to: :phone, with: { to: :phone_to_xml }
+      map_element "address", to: :address, with: { from: :address_from_xml }
+    end
+
+    def phone_to_json(model, doc)
+      doc["phone"] = "+1-#{model.phone}"
+    end
+
+    def address_from_json(model, value)
+      model.address = value.sub(/^Address: /, "")
+    end
+
+    def phone_to_xml(model, parent, doc)
+      el = doc.create_element("phone")
+      doc.add_text(el, "+1-#{model.phone}")
+      doc.add_element(parent, el)
+    end
+
+    def address_from_xml(model, value)
+      model.address = value.text.sub(/^Address: /, "")
+    end
+  end
 end
 
 RSpec.describe Lutaml::Model::Serializable do
@@ -151,48 +193,6 @@ RSpec.describe Lutaml::Model::Serializable do
     end
   end
 
-  describe ".hash_representation" do
-    context "when model is separate" do
-      let(:instance) do
-        SerializeableSpec::TestModel.new(name: "John", age: 18)
-      end
-
-      let(:expected_hash) do
-        {
-          "name" => "John",
-          "age" => "18",
-        }
-      end
-
-      it "return hash representation" do
-        generate_hash = SerializeableSpec::TestModelMapper.hash_representation(
-          instance, :yaml
-        )
-        expect(generate_hash).to eq(expected_hash)
-      end
-    end
-
-    context "when model is self" do
-      let(:instance) do
-        SerializeableSpec::TestMapper.new(name: "John", age: 18)
-      end
-
-      let(:expected_hash) do
-        {
-          "na" => "John",
-          "ag" => "18",
-        }
-      end
-
-      it "return hash representation" do
-        generate_hash = SerializeableSpec::TestMapper.hash_representation(
-          instance, :yaml
-        )
-        expect(generate_hash).to eq(expected_hash)
-      end
-    end
-  end
-
   describe ".mappings_for" do
     context "when mapping is defined" do
       it "returns the defined mapping" do
@@ -221,67 +221,68 @@ RSpec.describe Lutaml::Model::Serializable do
     end
   end
 
-  describe ".translate_mappings" do
-    let(:child_mappings) do
-      {
-        id: :key,
-        path: %i[path link],
-        name: %i[path name],
-      }
-    end
-
-    let(:hash) do
-      {
-        "foo" => {
-          "path" => {
-            "link" => "link one",
-            "name" => "one",
-          },
-        },
-        "abc" => {
-          "path" => {
-            "link" => "link two",
-            "name" => "two",
-          },
-        },
-        "hello" => {
-          "path" => {
-            "link" => "link three",
-            "name" => "three",
-          },
-        },
-      }
-    end
-
-    let(:attr) { SerializeableSpec::TranslateMappings.attributes[:translate] }
-
-    let(:expected_value) do
-      [
-        SerializeableSpec::TranslateHelper.new({
-                                                 "id" => "foo",
-                                                 "name" => "one",
-                                                 "path" => "link one",
-                                               }),
-        SerializeableSpec::TranslateHelper.new({
-                                                 "id" => "abc",
-                                                 "name" => "two",
-                                                 "path" => "link two",
-                                               }),
-        SerializeableSpec::TranslateHelper.new({
-                                                 "id" => "hello",
-                                                 "name" => "three",
-                                                 "path" => "link three",
-                                               }),
-      ]
-    end
-
-    it "generates hash based on child_mappings" do
-      actual_value = described_class.translate_mappings(hash, child_mappings, attr, :yaml)
-
-      expect(actual_value.map { |obj| [obj.id, obj.name, obj.path] })
-        .to eq(expected_value.map { |obj| [obj.id, obj.name, obj.path] })
-    end
-  end
+  # TODO: Move to key_value_transform specs
+  # describe ".translate_mappings" do
+  #   let(:child_mappings) do
+  #     {
+  #       id: :key,
+  #       path: %i[path link],
+  #       name: %i[path name],
+  #     }
+  #   end
+
+  #   let(:hash) do
+  #     {
+  #       "foo" => {
+  #         "path" => {
+  #           "link" => "link one",
+  #           "name" => "one",
+  #         },
+  #       },
+  #       "abc" => {
+  #         "path" => {
+  #           "link" => "link two",
+  #           "name" => "two",
+  #         },
+  #       },
+  #       "hello" => {
+  #         "path" => {
+  #           "link" => "link three",
+  #           "name" => "three",
+  #         },
+  #       },
+  #     }
+  #   end
+
+  #   let(:attr) { SerializeableSpec::TranslateMappings.attributes[:translate] }
+
+  #   let(:expected_value) do
+  #     [
+  #       SerializeableSpec::TranslateHelper.new({
+  #                                                "id" => "foo",
+  #                                                "name" => "one",
+  #                                                "path" => "link one",
+  #                                              }),
+  #       SerializeableSpec::TranslateHelper.new({
+  #                                                "id" => "abc",
+  #                                                "name" => "two",
+  #                                                "path" => "link two",
+  #                                              }),
+  #       SerializeableSpec::TranslateHelper.new({
+  #                                                "id" => "hello",
+  #                                                "name" => "three",
+  #                                                "path" => "link three",
+  #                                              }),
+  #     ]
+  #   end
+
+  #   it "generates hash based on child_mappings" do
+  #     actual_value = described_class.translate_mappings(hash, child_mappings, attr, :yaml)
+
+  #     expect(actual_value.map { |obj| [obj.id, obj.name, obj.path] })
+  #       .to eq(expected_value.map { |obj| [obj.id, obj.name, obj.path] })
+  #   end
+  # end
 
   describe "#key_value" do
     let(:model) { SerializeableSpec::KeyValueMapper }
@@ -386,4 +387,79 @@ RSpec.describe Lutaml::Model::Serializable do
       end
     end
   end
+
+  describe "Single option serialization" do
+    let(:attributes) do
+      {
+        name: "John Doe",
+        age: 30,
+        phone: "123-456-7890",
+        address: "123 Main St",
+      }
+    end
+
+    let(:model) { SerializeableSpec::SingleOptionModel.new(attributes) }
+
+    describe "JSON serialization" do
+      let(:expected_json) do
+        {
+          name: "John Doe",
+          age: 30,
+          phone: "+1-123-456-7890",
+          address: "123 Main St",
+        }.to_json
+      end
+
+      let(:parsed) do
+        SerializeableSpec::SingleOptionModel.from_json(
+          {
+            name: "John Doe",
+            age: 30,
+            phone: "123-456-7890",
+            address: "Address: 123 Main St",
+          }.to_json,
+        )
+      end
+
+      it "serializes to JSON with custom name transformation" do
+        expect(model.to_json).to eq(expected_json)
+      end
+
+      it "deserializes from JSON with custom name transformation" do
+        expect(parsed).to eq(model)
+      end
+    end
+
+    describe "XML serialization" do
+      let(:expected_xml) do
+        <<~XML
+          <person>
+            <name>John Doe</name>
+            <age>30</age>
+            <phone>+1-123-456-7890</phone>
+            <address>123 Main St</address>
+          </person>
+        XML
+      end
+
+      let(:parsed) do
+        SerializeableSpec::SingleOptionModel.from_xml <<~XML
+          <person>
+            <name>John Doe</name>
+            <age>30</age>
+            <phone>123-456-7890</phone>
+            <address>Address: 123 Main St</address>
+          </person>
+        XML
+      end
+
+      it "serializes to XML with custom name transformation" do
+        expect(model.to_xml).to be_equivalent_to(expected_xml)
+      end
+
+      it "deserializes from XML with custom name transformation" do
+        expect(parsed).to eq(model)
+      end
+    end
+  end
 end