lutaml-model 0.6.7 → 0.7.2

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

@@ -1,6 +1,6 @@
 require "spec_helper"
-require "lutaml/model/toml_adapter/toml_rb_adapter"
-require "lutaml/model/toml_adapter/tomlib_adapter"
+require "lutaml/model/toml/toml_rb_adapter"
+require "lutaml/model/toml/tomlib_adapter"
 require_relative "../../fixtures/sample_model"
 
 RSpec.describe "TomlAdapter" do
@@ -9,9 +9,9 @@ RSpec.describe "TomlAdapter" do
     let(:model) { SampleModel.new(attributes) }
 
     let(:expected_toml) do
-      if adapter_class == Lutaml::Model::TomlAdapter::TomlRbAdapter
+      if adapter_class == Lutaml::Model::Toml::TomlRbAdapter
         TomlRB.dump(attributes)
-      elsif adapter_class == Lutaml::Model::TomlAdapter::TomlibAdapter
+      elsif adapter_class == Lutaml::Model::Toml::TomlibAdapter
         Tomlib.dump(attributes)
       end
     end
@@ -31,11 +31,11 @@ RSpec.describe "TomlAdapter" do
     end
   end
 
-  describe Lutaml::Model::TomlAdapter::TomlRbAdapter do
+  describe Lutaml::Model::Toml::TomlRbAdapter do
     it_behaves_like "a TOML adapter", described_class
   end
 
-  describe Lutaml::Model::TomlAdapter::TomlibAdapter do
+  describe Lutaml::Model::Toml::TomlibAdapter do
     it_behaves_like "a TOML adapter", described_class
   end
 end

data/spec/lutaml/model/toml_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/toml"
+
+RSpec.describe Lutaml::Model::Toml do
+  describe ".detect_toml_adapter" do
+    before do
+      # Hide any existing constants first
+      hide_const("Tomlib") if Object.const_defined?(:Tomlib)
+      hide_const("TomlRb") if Object.const_defined?(:TomlRb)
+    end
+
+    context "when Tomlib is available" do
+      before do
+        stub_const("Tomlib", Module.new)
+      end
+
+      it "returns :tomlib" do
+        expect(described_class.detect_toml_adapter).to eq(:tomlib)
+      end
+    end
+
+    context "when TomlRb is available" do
+      before do
+        stub_const("TomlRb", Module.new)
+      end
+
+      it "returns :toml_rb" do
+        expect(described_class.detect_toml_adapter).to eq(:toml_rb)
+      end
+    end
+
+    context "when neither adapter is available" do
+      it "returns nil" do
+        expect(described_class.detect_toml_adapter).to be_nil
+      end
+    end
+
+    context "when both adapters are available" do
+      before do
+        stub_const("Tomlib", Module.new)
+        stub_const("TomlRb", Module.new)
+      end
+
+      it "prefers Tomlib" do
+        expect(described_class.detect_toml_adapter).to eq(:tomlib)
+      end
+    end
+  end
+end

data/spec/lutaml/model/transformation_spec.rb

@@ -56,7 +56,7 @@ module TransformationSpec
       import: ->(value) { value.to_s.downcase },
     }
     attribute :email, :string, transform: {
-      export: lambda(&:downcase),
+      export: lambda(&:upcase),
       import: lambda(&:downcase),
     }
     attribute :tags, :string, collection: true, transform: {
@@ -82,13 +82,36 @@ module TransformationSpec
         export: ->(value) { "Prof. #{value}" },
         import: ->(value) { value.gsub("Prof. ", "") },
       }
-      map_element "contact-email", to: :email, transform: {
+      map_attribute "contact-email", to: :email, transform: {
         export: ->(value) { "contact+#{value}" },
         import: ->(value) { value.gsub("contact+", "") },
       }
       map_element "skills", to: :tags
     end
   end
+
+  class RoundTripTransformations < Lutaml::Model::Serializable
+    attribute :number, :string, transform: {
+      import: ->(value) { (value.to_f + 1).to_s },
+      export: ->(value) { (value.to_f - 1).to_s },
+    }
+
+    json do
+      map "number", to: :number, transform: {
+        import: ->(value) { ((value.to_f * 10) + 1).to_s },
+        export: ->(value) { ((value.to_f - 1) / 10.0).to_s },
+      }
+    end
+
+    xml do
+      root "RoundTripTransformations"
+
+      map_element "number", to: :number, transform: {
+        import: ->(value) { ((value.to_f * 10) + 1).to_s },
+        export: ->(value) { ((value.to_f - 1) / 10.0).to_s },
+      }
+    end
+  end
 end
 
 RSpec.describe "Value Transformations" do
@@ -147,6 +170,18 @@ RSpec.describe "Value Transformations" do
       )
     end
 
+    let(:json) do
+      {
+        "fullName" => "Dr. bob",
+        "emailAddress" => "bobattest.com",
+        "labels" => "senior|lead",
+      }.to_json
+    end
+
+    let(:parsed) do
+      TransformationSpec::MappingTransformPerson.from_json(json)
+    end
+
     let(:expected_xml) do
       <<~XML
         <person>
@@ -165,16 +200,15 @@ RSpec.describe "Value Transformations" do
       expect(parsed["labels"]).to eq("developer-|-architect")
     end
 
-    it "applies mapping transformations during JSON deserialization" do
-      json = {
-        "fullName" => "Dr. bob",
-        "emailAddress" => "bobattest.com",
-        "labels" => "senior|lead",
-      }.to_json
-
-      parsed = TransformationSpec::MappingTransformPerson.from_json(json)
+    it "correctly deserialize name from JSON" do
       expect(parsed.name).to eq("Dr. bob")
+    end
+
+    it "correctly deserialize email from JSON" do
       expect(parsed.email).to eq("bob@test.com")
+    end
+
+    it "correctly deserialize tags from JSON" do
       expect(parsed.tags).to eq(["senior", "lead"])
     end
 
@@ -195,9 +229,8 @@ RSpec.describe "Value Transformations" do
 
     let(:expected_xml) do
       <<~XML
-        <person>
-          <full-name>Prof. carol</full-name>
-          <contact-email>contact+CAROL@TEST.COM</contact-email>
+        <person contact-email="contact+CAROL@TEST.COM">
+          <full-name>Prof. Carol</full-name>
           <skills>MANAGER-1</skills>
           <skills>AGILE-1</skills>
         </person>
@@ -208,7 +241,7 @@ RSpec.describe "Value Transformations" do
       json = combined_person.to_json
       parsed = JSON.parse(json)
 
-      expect(parsed["fullName"]).to eq("Prof. carol")
+      expect(parsed["fullName"]).to eq("Prof. Carol")
       expect(parsed["contactEmail"]).to eq("contact+CAROL@TEST.COM")
     end
 
@@ -217,7 +250,7 @@ RSpec.describe "Value Transformations" do
       json = combined_person.to_json
       parsed_json = TransformationSpec::CombinedTransformPerson.from_json(json)
       expect(parsed_json.name).to eq("carol")
-      expect(parsed_json.email).to eq("CAROL@TEST.COM")
+      expect(parsed_json.email).to eq("carol@test.com")
       expect(parsed_json.tags).to eq(["MANAGER-1", "AGILE-1"])
     end
 
@@ -227,4 +260,28 @@ RSpec.describe "Value Transformations" do
       expect(parsed_xml.to_xml).to be_equivalent_to(expected_xml)
     end
   end
+
+  describe "Custom Transformations all mappings applied" do
+    let(:xml) do
+      <<~XML
+        <RoundTripTransformations>
+          <number>10.0</number>
+        </RoundTripTransformations>
+      XML
+    end
+
+    let(:json) do
+      { number: "10.0" }.to_json
+    end
+
+    it "correctly round trips XML" do
+      parsed = TransformationSpec::RoundTripTransformations.from_xml(xml)
+      expect(parsed.to_xml).to be_equivalent_to(xml)
+    end
+
+    it "correctly round trips JSON" do
+      parsed = TransformationSpec::RoundTripTransformations.from_json(json)
+      expect(parsed.to_json).to be_equivalent_to(json)
+    end
+  end
 end

data/spec/lutaml/model/uninitialized_class_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+RSpec.describe Lutaml::Model::UninitializedClass do
+  subject(:uninitialized) { described_class.instance }
+
+  describe "#to_s" do
+    it "returns self" do
+      expect(uninitialized.to_s).to eq(uninitialized)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns 'uninitialized'" do
+      expect(uninitialized.inspect).to eq("uninitialized")
+    end
+  end
+
+  describe "#uninitialized?" do
+    it "returns true" do
+      expect(uninitialized.uninitialized?).to be true
+    end
+  end
+
+  describe "#match?" do
+    it "returns false for any argument" do
+      expect(uninitialized).not_to match /pattern/
+      expect(uninitialized).not_to match "string"
+      expect(uninitialized).not_to match nil
+    end
+  end
+
+  describe "#include?" do
+    it "returns false for any argument" do
+      expect(uninitialized).not_to include "substring"
+      expect(uninitialized).not_to include nil
+    end
+  end
+
+  describe "#gsub" do
+    it "returns self regardless of arguments" do
+      expect(uninitialized.gsub("pattern", "replacement")).to eq(uninitialized)
+      expect(uninitialized.gsub("pattern", "replacement")).to eq(uninitialized)
+    end
+  end
+
+  describe "#to_yaml" do
+    it "returns nil" do
+      expect(uninitialized.to_yaml).to be_nil
+    end
+  end
+
+  describe "#to_f" do
+    it "returns self" do
+      expect(uninitialized.to_f).to eq(uninitialized)
+    end
+  end
+
+  describe "#size" do
+    it "returns 0" do
+      expect(uninitialized.size).to eq(0)
+    end
+  end
+
+  describe "#encoding" do
+    it "returns the default string encoding" do
+      expect(uninitialized.encoding).to eq("".encoding)
+    end
+  end
+
+  describe "method_missing" do
+    context "when method ends with '?'" do
+      it "returns false" do
+        expect(uninitialized).not_to be_empty
+        expect(uninitialized).not_to be_nil
+        expect(uninitialized).not_to be_blank
+      end
+    end
+
+    context "when method doesn't end with '?'" do
+      it "raises NoMethodError" do
+        expect { uninitialized.unknown_method }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe "#respond_to_missing?" do
+    it "returns true for methods ending with ?" do
+      expect(uninitialized.respond_to?(:empty?)).to be true
+      expect(uninitialized.respond_to?(:nil?)).to be true
+    end
+
+    it "returns false for methods not ending with ?" do
+      expect(uninitialized.respond_to?(:unknown_method)).to be false
+    end
+  end
+end

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