lutaml-model 0.7.1 → 0.7.3

data/spec/lutaml/model/polymorphic_spec.rb

@@ -47,12 +47,63 @@ module PolymorphicSpec
       end
     end
 
+    module InvalidClasses
+      class AnchorReference < Lutaml::Model::Serializable
+        attribute :anchor_id, :string
+
+        xml do
+          map_element "anchor_id", to: :anchor_id
+        end
+
+        key_value do
+          map "anchor_id", to: :anchor_id
+        end
+      end
+
+      class DocumentReference < Reference
+        attribute :document_id, :string
+
+        xml do
+          map_element "document_id", to: :document_id
+        end
+
+        key_value do
+          map "document_id", to: :document_id
+        end
+      end
+    end
+
     class ReferenceSet < Lutaml::Model::Serializable
       attribute :references, Reference, collection: true, polymorphic: [
         DocumentReference,
         AnchorReference,
       ]
     end
+
+    class SimpleReferenceSet < Lutaml::Model::Serializable
+      attribute :references, Reference, collection: true, polymorphic: true
+
+      xml do
+        root "ReferenceSet"
+        map_element "references", to: :references, polymorphic: {
+          attribute: "reference-type",
+          class_map: {
+            "document-ref" => "PolymorphicSpec::Base::DocumentReference",
+            "anchor-ref" => "PolymorphicSpec::Base::AnchorReference",
+          },
+        }
+      end
+
+      key_value do
+        map "references", to: :references, polymorphic: {
+          attribute: "_class",
+          class_map: {
+            "Document" => "PolymorphicSpec::Base::DocumentReference",
+            "Anchor" => "PolymorphicSpec::Base::AnchorReference",
+          },
+        }
+      end
+    end
   end
 
   module Child
@@ -226,6 +277,133 @@ RSpec.describe "Polymorphic" do
     end
   end
 
+  context "when using polymorphic: true option" do
+    context "when key_value formats" do
+      let(:reference_set) do
+        PolymorphicSpec::Base::SimpleReferenceSet.new(
+          references: [
+            PolymorphicSpec::Base::DocumentReference.new(
+              _class: "Document",
+              document_id: "book:tbtd",
+              name: "The Tibetan Book of the Dead",
+            ),
+            PolymorphicSpec::Base::AnchorReference.new(
+              _class: "Anchor",
+              anchor_id: "book:tbtd:anchor-1",
+              name: "Chapter 1",
+            ),
+          ],
+        )
+      end
+
+      let(:invalid_reference_set) do
+        PolymorphicSpec::Base::SimpleReferenceSet.new(
+          references: [
+            PolymorphicSpec::Base::InvalidClasses::DocumentReference.new(
+              _class: "Document",
+              document_id: "book:tbtd",
+              name: "The Tibetan Book of the Dead",
+            ),
+            PolymorphicSpec::Base::InvalidClasses::AnchorReference.new(
+              _class: "Anchor",
+              anchor_id: "book:tbtd:anchor-1",
+              name: "Chapter 1",
+            ),
+          ],
+        )
+      end
+
+      let(:yaml) do
+        <<~YAML
+          ---
+          references:
+          - _class: Document
+            name: The Tibetan Book of the Dead
+            document_id: book:tbtd
+          - _class: Anchor
+            name: Chapter 1
+            anchor_id: book:tbtd:anchor-1
+        YAML
+      end
+
+      let(:parsed_yaml) do
+        PolymorphicSpec::Base::SimpleReferenceSet.from_yaml(yaml)
+      end
+
+      let(:error_message) do
+        "PolymorphicSpec::Base::InvalidClasses::AnchorReference is not " \
+          "valid sub class of PolymorphicSpec::Base::Reference"
+      end
+
+      it "deserializes correctly" do
+        expect(parsed_yaml).to eq(reference_set)
+      end
+
+      it "serializes correctly" do
+        expect(parsed_yaml.to_yaml).to eq(yaml)
+      end
+
+      it "raises error" do
+        expect do
+          invalid_reference_set.validate!
+        end.to raise_error(Lutaml::Model::ValidationError, error_message)
+      end
+    end
+
+    context "when XML format" do
+      let(:reference_set) do
+        PolymorphicSpec::Base::SimpleReferenceSet.new(
+          references: [
+            PolymorphicSpec::Base::DocumentReference.new(
+              _class: "document-ref",
+              document_id: "book:tbtd",
+              name: "The Tibetan Book of the Dead",
+            ),
+            PolymorphicSpec::Base::AnchorReference.new(
+              _class: "anchor-ref",
+              anchor_id: "book:tbtd:anchor-1",
+              name: "Chapter 1",
+            ),
+          ],
+        )
+      end
+      let(:xml) do
+        <<~XML
+          <ReferenceSet>
+            <references reference-type="document-ref">
+              <name>The Tibetan Book of the Dead</name>
+              <document_id>book:tbtd</document_id>
+            </references>
+            <references reference-type="anchor-ref">
+              <name>Chapter 1</name>
+              <anchor_id>book:tbtd:anchor-1</anchor_id>
+            </references>
+          </ReferenceSet>
+        XML
+      end
+
+      let(:parsed_xml) do
+        PolymorphicSpec::Base::SimpleReferenceSet.from_xml(xml)
+      end
+
+      it "deserializes correctly" do
+        expect(parsed_xml).to eq(reference_set)
+      end
+
+      it "serializes correctly" do
+        expect(parsed_xml.to_xml.strip).to be_equivalent_to(xml.strip)
+      end
+
+      it "does not raise error if polymorphic is set to true" do
+        expect { reference_set.validate! }.not_to raise_error
+      end
+
+      it "has empty errors array on validate" do
+        expect(reference_set.validate).to eq([])
+      end
+    end
+  end
+
   context "when defined in child class" do
     context "when key_value formats" do
       let(:reference_set) do

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

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