lutaml-model 0.6.7 → 0.7.1

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/simple_model_spec.rb

@@ -62,26 +62,26 @@ module SimpleModel
     xml do
       root "building"
       map_attribute "name", to: :name
-      map_element "address", to: :address
-      map_element "room", to: :rooms
+      map_element "address", to: :address, treat_omitted: :omited
+      map_element "room", to: :rooms, treat_omitted: :omited
     end
 
     yaml do
       map "name", to: :name
-      map "address", to: :address
-      map "rooms", to: :rooms
+      map "address", to: :address, treat_omitted: :omited
+      map "rooms", to: :rooms, treat_omitted: :omited
     end
 
     json do
       map "name", to: :name
-      map "address", to: :address
-      map "rooms", to: :rooms
+      map "address", to: :address, treat_omitted: :omited
+      map "rooms", to: :rooms, treat_omitted: :omited
     end
 
     toml do
       map "name", to: :name
-      map "address", to: :address
-      map "rooms", to: :rooms
+      map "address", to: :address, treat_omitted: :omited
+      map "rooms", to: :rooms, treat_omitted: :omited
     end
   end
 end
@@ -182,7 +182,7 @@ RSpec.describe SimpleModel do
     default_model = SimpleModel::Building.new
     expect(default_model.name).to eq("Unnamed building")
     expect(default_model.address).to be_nil
-    expect(default_model.rooms).to eq([])
+    expect(default_model.rooms).to be_nil
   end
 
   it "serializes to XML" do

data/spec/lutaml/model/value_map_spec.rb

@@ -0,0 +1,240 @@
+# map :x, to: :y, value_map: {
+#   from_xml: {omitted: :omitted, xsi_nil: nil, empty: [] },
+#   to_xml: {omitted: :omitted, nil: :nil, empty: :empty}
+# }
+
+module ValueMapSpec
+  class WithValueMaps < Lutaml::Model::Serializable
+    attribute :omitted_as_omitted, :string
+    attribute :omitted_as_nil, :string
+    attribute :omitted_as_empty, :string
+
+    attribute :nil_as_nil, :string
+    attribute :nil_as_omitted, :string
+    attribute :nil_as_empty, :string
+
+    attribute :empty_as_empty, :string
+    attribute :empty_as_nil, :string
+    attribute :empty_as_omitted, :string
+
+    xml do
+      root "WithValueMaps"
+
+      map_element "omittedAsOmitted", to: :omitted_as_omitted, value_map: {
+        from: { omitted: :omitted },
+        to: { omitted: :omitted },
+      }
+      map_element "omittedAsNil", to: :omitted_as_nil, value_map: {
+        from: { omitted: :nil },
+        to: { omitted: :nil },
+      }
+      map_element "omittedAsEmpty", to: :omitted_as_empty, value_map: {
+        from: { omitted: :empty },
+        to: { omitted: :empty },
+      }
+
+      map_element "nilAsNil", to: :nil_as_nil, value_map: {
+        from: { nil: :nil },
+        to: { nil: :nil },
+      }
+      map_element "nilAsOmitted", to: :nil_as_omitted, value_map: {
+        from: { nil: :omitted },
+        to: { nil: :omitted },
+      }
+      map_element "nilAsEmpty", to: :nil_as_empty, value_map: {
+        from: { nil: :empty },
+        to: { nil: :empty },
+      }
+
+      map_element "emptyAsEmpty", to: :empty_as_empty, value_map: {
+        from: { empty: :empty },
+        to: { empty: :empty },
+      }
+      map_element "emptyAsNil", to: :empty_as_nil, value_map: {
+        from: { empty: :nil },
+        to: { empty: :nil },
+      }
+      map_element "emptyAsOmitted", to: :empty_as_omitted, value_map: {
+        from: { empty: :omitted },
+        to: { empty: :omitted },
+      }
+    end
+
+    key_value do
+      map "omitted_as_omitted", to: :omitted_as_omitted, value_map: {
+        from: { omitted: :omitted },
+        to: { omitted: :omitted },
+      }
+      map "omitted_as_nil", to: :omitted_as_nil, value_map: {
+        from: { omitted: :omitted },
+        to: { omitted: :nil },
+      }
+      map "omitted_as_empty", to: :omitted_as_empty, value_map: {
+        from: { omitted: :omitted },
+        to: { omitted: :empty },
+      }
+
+      map "nil_as_nil", to: :nil_as_nil, value_map: {
+        from: { nil: :nil },
+        to: { nil: :nil },
+      }
+      map "nil_as_omitted", to: :nil_as_omitted, value_map: {
+        from: { nil: :nil },
+        to: { nil: :omitted },
+      }
+      map "nil_as_empty", to: :nil_as_empty, value_map: {
+        from: { nil: :nil },
+        to: { nil: :empty },
+      }
+
+      map "empty_as_empty", to: :empty_as_empty, value_map: {
+        from: { empty: :empty },
+        to: { empty: :empty },
+      }
+      map "empty_as_nil", to: :empty_as_nil, value_map: {
+        from: { empty: :empty },
+        to: { empty: :nil },
+      }
+      map "empty_as_omitted", to: :empty_as_omitted, value_map: {
+        from: { empty: :empty },
+        to: { empty: :omitted },
+      }
+    end
+  end
+end
+
+RSpec.describe "ValueMap" do
+  describe "YAML" do
+    let(:model) do
+      uninitialized = Lutaml::Model::UninitializedClass.instance
+
+      ValueMapSpec::WithValueMaps.new(
+        omitted_as_omitted: uninitialized,
+        omitted_as_nil: uninitialized,
+        omitted_as_empty: uninitialized,
+        nil_as_nil: nil,
+        nil_as_omitted: nil,
+        nil_as_empty: nil,
+        empty_as_empty: "",
+        empty_as_nil: "",
+        empty_as_omitted: "",
+      )
+    end
+
+    let(:parsed) { ValueMapSpec::WithValueMaps.from_yaml(yaml) }
+
+    let(:expected_yaml) do
+      <<~YAML
+        ---
+        omitted_as_nil:
+        omitted_as_empty: ''
+        nil_as_nil:
+        nil_as_empty: ''
+        empty_as_empty: ''
+        empty_as_nil:
+      YAML
+    end
+
+    let(:yaml) do
+      <<~YAML
+        ---
+        nil_as_nil:
+        nil_as_omitted:
+        nil_as_empty:
+        empty_as_empty: ''
+        empty_as_nil: ''
+        empty_as_omitted: ''
+      YAML
+    end
+
+    it "serializes correctly" do
+      expect(parsed.to_yaml).to eq(expected_yaml)
+    end
+
+    it "deserializes correctly" do
+      expected = ValueMapSpec::WithValueMaps.new(
+        {
+          nil_as_nil: nil,
+          nil_as_omitted: nil,
+          nil_as_empty: nil,
+          empty_as_empty: "",
+          empty_as_nil: "",
+          empty_as_omitted: "",
+        },
+        { omitted: :omitted },
+      )
+
+      expect(parsed).to eq(expected)
+    end
+  end
+
+  describe "XML" do
+    context "when serializing" do
+      let(:model) do
+        ValueMapSpec::WithValueMaps.new(
+          {
+            nil_as_nil: nil,
+            nil_as_omitted: nil,
+            nil_as_empty: nil,
+            empty_as_empty: "",
+            empty_as_nil: "",
+            empty_as_omitted: "",
+          },
+          { omitted: :omitted },
+        )
+      end
+
+      let(:expected_xml) do
+        <<~XML.strip
+          <WithValueMaps>
+            <omittedAsNil xsi:nil="true"/>
+            <omittedAsEmpty/>
+            <nilAsNil xsi:nil="true"/>
+            <nilAsEmpty/>
+            <emptyAsEmpty/>
+            <emptyAsNil xsi:nil="true"/>
+          </WithValueMaps>
+        XML
+      end
+
+      it "sets correct values when serializing" do
+        expect(model.to_xml).to eq(expected_xml)
+      end
+    end
+
+    context "when deserializing" do
+      let(:xml) do
+        <<~XML
+          <WithValueMaps>
+            <nilAsNil xsi:nil="true" />
+            <nilAsOmitted xsi:nil="true" />
+            <nilAsEmpty xsi:nil="true" />
+            <emptyAsEmpty/>
+            <emptyAsNil/>
+            <emptyAsOmitted/>
+          </WithValueMaps>
+        XML
+      end
+
+      let(:parsed) { ValueMapSpec::WithValueMaps.from_xml(xml) }
+
+      let(:expected) do
+        ValueMapSpec::WithValueMaps.new(
+          {
+            nil_as_nil: nil,
+            nil_as_empty: "",
+            empty_as_empty: "",
+            empty_as_nil: nil,
+            omitted_as_nil: nil,
+            omitted_as_empty: "",
+          },
+          { omitted: :omitted },
+        )
+      end
+
+      it "sets correct values when deserializing" do
+        expect(parsed).to eq(expected)
+      end
+    end
+  end
+end

data/spec/lutaml/model/xml/namespace/nested_with_explicit_namespace_spec.rb

@@ -0,0 +1,85 @@
+# <Base xmlns:test="https://test-namespace">
+#   <test:Element1>
+#     <test:Element>Value</test:Element>
+#     <ElementWithoutNamespace>
+#       <NestedElementWithoutNamespace>
+#         Value for nested element without namespace
+#       </NestedElementWithoutNamespace>
+#     </ElementWithoutNamespace>
+#   </test:Element1>
+# </Base>
+
+module NestedWithExplicitNamespaceSpec
+  class NestedElementWithoutNamespace < Lutaml::Model::Serializable
+    attribute :nested_element_without_namespace, :string
+
+    xml do
+      map_element "NestedElementWithoutNamespace",
+                  to: :nested_element_without_namespace
+    end
+  end
+
+  class ElementWithoutNamespace < Lutaml::Model::Serializable
+    attribute :nested_element_without_namespace, :string
+
+    xml do
+      map_element "NestedElementWithoutNamespace",
+                  to: :nested_element_without_namespace
+    end
+  end
+
+  class Element1 < Lutaml::Model::Serializable
+    attribute :element, :string
+    attribute :element_without_namespace, ElementWithoutNamespace
+
+    xml do
+      map_element "Element", to: :element
+      map_element "ElementWithoutNamespace", to: :element_without_namespace,
+                                             namespace: nil,
+                                             prefix: nil
+    end
+  end
+
+  class Base < Lutaml::Model::Serializable
+    attribute :element1, Element1
+
+    xml do
+      root "Base"
+      namespace "https://test-namespace", "test"
+
+      map_element "Element1", to: :element1
+    end
+  end
+end
+
+RSpec.describe "NestedWithExplicitNamespace" do
+  let(:xml) do
+    <<~XML
+      <Base xmlns:test="https://test-namespace">
+        <test:Element1>
+          <test:Element>Value</test:Element>
+          <ElementWithoutNamespace>
+            <NestedElementWithoutNamespace>
+              Value for nested element without namespace
+            </NestedElementWithoutNamespace>
+          </ElementWithoutNamespace>
+        </test:Element1>
+      </Base>
+    XML
+  end
+
+  let(:parsed) { NestedWithExplicitNamespaceSpec::Base.from_xml(xml) }
+
+  it "parses namespaced element correctly" do
+    expect(parsed.element1.element).to eq("Value")
+  end
+
+  it "parses nested element without namespace correclty" do
+    generated_value = parsed.element1
+      .element_without_namespace
+      .nested_element_without_namespace
+      .strip
+
+    expect(generated_value).to eq("Value for nested element without namespace")
+  end
+end