lutaml-model 0.4.0 → 0.5.1

data/spec/lutaml/model/multiple_mapping_spec.rb

@@ -0,0 +1,329 @@
+require "spec_helper"
+require "lutaml/model"
+
+module MultipleMapping
+  class Product < Lutaml::Model::Serializable
+    attribute :name, Lutaml::Model::Type::String
+    attribute :localized_name, Lutaml::Model::Type::String
+    attribute :description, Lutaml::Model::Type::String
+    attribute :status, Lutaml::Model::Type::String
+    attribute :content, Lutaml::Model::Type::String
+
+    yaml do
+      map ["name", "product_name"], to: :name
+      map ["desc", "description"], to: :description
+    end
+
+    json do
+      map ["name", "product_name"], to: :name
+      map ["desc", "description"], to: :description
+    end
+
+    toml do
+      map ["name", "product_name"], to: :name
+      map ["desc", "description"], to: :description
+    end
+
+    xml do
+      root "product"
+      map_element ["name", "product-name"], to: :name
+      map_element ["localized-name", "localized_name"], to: :localized_name
+      map_element ["desc", "description"], to: :description
+      map_attribute ["status", "product-status"], to: :status
+      map_content to: :content
+    end
+  end
+
+  class CustomModel < Lutaml::Model::Serializable
+    attribute :id, Lutaml::Model::Type::String
+    attribute :full_name, Lutaml::Model::Type::String
+    attribute :size, Lutaml::Model::Type::Integer
+    attribute :color, Lutaml::Model::Type::String
+    attribute :description, Lutaml::Model::Type::String
+
+    json do
+      map ["name", "custom_name"], with: { to: :name_to_json, from: :name_from_json }
+      map ["color", "shade"], with: { to: :color_to_json, from: :color_from_json }
+      map ["size", "dimension"], with: { to: :size_to_json, from: :size_from_json }
+      map ["desc", "description"], with: { to: :desc_to_json, from: :desc_from_json }
+    end
+
+    xml do
+      root "CustomModel"
+      map_attribute ["id", "identifier"], with: { to: :id_to_xml, from: :id_from_xml }
+      map_element ["name", "custom-name"], with: { to: :name_to_xml, from: :name_from_xml }
+      map_element ["color", "shade"], with: { to: :color_to_xml, from: :color_from_xml }
+      map_element ["size", "dimension"], with: { to: :size_to_xml, from: :size_from_xml }
+      map_element ["desc", "description"], with: { to: :desc_to_xml, from: :desc_from_xml }
+    end
+
+    # Custom methods for JSON
+    def name_to_json(model, doc)
+      doc["name"] = "JSON Model: #{model.full_name}"
+    end
+
+    def name_from_json(model, value)
+      model.full_name = value&.sub(/^JSON Model: /, "")
+    end
+
+    def color_to_json(model, doc)
+      doc["color"] = model.color.upcase
+    end
+
+    def color_from_json(model, value)
+      model.color = value&.downcase
+    end
+
+    def size_to_json(model, doc)
+      doc["size"] = model.size + 10
+    end
+
+    def size_from_json(model, value)
+      model.size = value - 10
+    end
+
+    def desc_to_json(model, doc)
+      doc["desc"] = "JSON Description: #{model.description}"
+    end
+
+    def desc_from_json(model, value)
+      model.description = value&.sub(/^JSON Description: /, "")
+    end
+
+    # Custom methods for XML
+    def id_to_xml(model, parent, doc)
+      doc.add_attribute(parent, "id", "XML-#{model.id}")
+    end
+
+    def id_from_xml(model, value)
+      model.id = value&.sub(/^XML-/, "")
+    end
+
+    def name_to_xml(model, parent, doc)
+      el = doc.create_element("name")
+      doc.add_text(el, "XML Model: #{model.full_name}")
+      doc.add_element(parent, el)
+    end
+
+    def name_from_xml(model, value)
+      model.full_name = value.sub(/^XML Model: /, "")
+    end
+
+    def color_to_xml(model, parent, doc)
+      el = doc.create_element("color")
+      doc.add_text(el, model.color.upcase)
+      doc.add_element(parent, el)
+    end
+
+    def color_from_xml(model, value)
+      model.color = value.downcase
+    end
+
+    def size_to_xml(model, parent, doc)
+      el = doc.create_element("size")
+      doc.add_text(el, (model.size + 10).to_s)
+      doc.add_element(parent, el)
+    end
+
+    def size_from_xml(model, value)
+      model.size = (value.to_i || 0) - 10
+    end
+
+    def desc_to_xml(model, parent, doc)
+      el = doc.create_element("desc")
+      doc.add_text(el, "XML Description: #{model.description}")
+      doc.add_element(parent, el)
+    end
+
+    def desc_from_xml(model, value)
+      model.description = value.sub(/^XML Description: /, "")
+    end
+  end
+end
+
+RSpec.describe MultipleMapping do
+  context "with key-value formats" do
+    context "with YAML format" do
+      let(:yaml_with_name) { "product_name: Coffee Maker\ndescription: Premium coffee maker" }
+      let(:yaml_with_desc) { "---\nname: Coffee Maker\ndesc: Premium coffee maker\n" }
+
+      it "handles bidirectional conversion" do
+        product1 = MultipleMapping::Product.from_yaml(yaml_with_name)
+        product2 = MultipleMapping::Product.from_yaml(yaml_with_desc)
+
+        # keys for name and description are :name and :desc respectively since
+        # they are first element in their respective mapping array
+
+        expected_yaml = "---\nname: Coffee Maker\ndesc: Premium coffee maker\n"
+        expect(product1.to_yaml).to eq(expected_yaml)
+        expect(product2.to_yaml).to eq(yaml_with_desc)
+      end
+    end
+
+    context "with JSON format" do
+      let(:json_with_name) { '{"product_name":"Coffee Maker","description":"Premium coffee maker"}' }
+      let(:json_with_desc) { '{"name":"Coffee Maker","desc":"Premium coffee maker"}' }
+
+      it "handles bidirectional conversion" do
+        product1 = MultipleMapping::Product.from_json(json_with_name)
+        product2 = MultipleMapping::Product.from_json(json_with_desc)
+
+        # keys for name and description are :name and :desc respectively since
+        # they are first element in their respective mapping array
+        expected_json = '{"name":"Coffee Maker","desc":"Premium coffee maker"}'
+
+        expect(product1.to_json).to eq(expected_json)
+        expect(product2.to_json).to eq(json_with_desc)
+      end
+    end
+  end
+
+  context "with XML format" do
+    shared_examples "xml adapter with multiple mappings" do |adapter_class|
+      before do
+        Lutaml::Model::Config.xml_adapter = adapter_class
+      end
+
+      around do |example|
+        old_adapter = Lutaml::Model::Config.xml_adapter
+        Lutaml::Model::Config.xml_adapter = adapter_class
+
+        example.run
+      ensure
+        Lutaml::Model::Config.xml_adapter = old_adapter
+      end
+
+      let(:xml_with_attributes) do
+        <<~XML
+          <product status="active">
+            Some content here
+            <name>Coffee Maker</name>
+            <description>Premium coffee maker</description>
+          </product>
+        XML
+      end
+
+      let(:xml_with_alternate_attributes) do
+        <<~XML
+          <product product-status="in-stock">
+            Different content
+            <product-name>Coffee Maker</product-name>
+            <desc>Premium coffee maker</desc>
+          </product>
+        XML
+      end
+
+      it "handles bidirectional conversion with attributes and content" do
+        product1 = MultipleMapping::Product.from_xml(xml_with_attributes)
+        product2 = MultipleMapping::Product.from_xml(xml_with_alternate_attributes)
+
+        # Key for element name is :name since it is first element in mapping array and same for status attribute
+        expected_xml_product1 = <<~XML
+          <product status="active">
+            <name>Coffee Maker</name>
+            <desc>Premium coffee maker</desc>
+            Some content here
+          </product>
+        XML
+
+        expected_xml_product2 = <<~XML
+          <product status="in-stock">
+            <name>Coffee Maker</name>
+            <desc>Premium coffee maker</desc>
+            Different content
+          </product>
+        XML
+
+        expect(product1.name).to eq("Coffee Maker")
+        expect(product1.status).to eq("active")
+        expect(product2.status).to eq("in-stock")
+
+        expect(product1.to_xml).to be_equivalent_to(expected_xml_product1)
+        expect(product2.to_xml).to be_equivalent_to(expected_xml_product2)
+      end
+    end
+
+    context "with Nokogiri adapter" do
+      it_behaves_like "xml adapter with multiple mappings", Lutaml::Model::XmlAdapter::NokogiriAdapter
+    end
+
+    context "with Ox adapter" do
+      it_behaves_like "xml adapter with multiple mappings", Lutaml::Model::XmlAdapter::OxAdapter
+    end
+  end
+
+  context "with CustomModel" do
+    context "with JSON format" do
+      let(:json_with_alternate) { '{"custom_name":"JSON Model: Vase","shade":"BLUE","dimension":22,"description":"JSON Description: A beautiful ceramic vase"}' }
+      let(:json_with_standard) { '{"name":"JSON Model: Vase","color":"BLUE","size":22,"desc":"JSON Description: A beautiful ceramic vase"}' }
+
+      it "handles bidirectional conversion with custom methods" do
+        model1 = MultipleMapping::CustomModel.from_json(json_with_alternate)
+        model2 = MultipleMapping::CustomModel.from_json(json_with_standard)
+
+        # keys are 'name', 'color', 'size', 'desc' respectively since
+        # they are first element in their respective mapping array
+        expected_json = '{"name":"JSON Model: Vase","color":"BLUE","size":22,"desc":"JSON Description: A beautiful ceramic vase"}'
+
+        expect(model1.to_json).to eq(expected_json)
+        expect(model2.to_json).to eq(expected_json)
+      end
+    end
+
+    context "with XML format" do
+      shared_examples "xml adapter with custom methods" do |_adapter_class|
+        before do
+          Lutaml::Model::Config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+        end
+
+        let(:xml_with_alternate) do
+          <<~XML
+            <CustomModel identifier="123">
+              <custom-name>XML Model: Vase</custom-name>
+              <shade>BLUE</shade>
+              <dimension>22</dimension>
+              <description>XML Description: A beautiful ceramic vase</description>
+            </CustomModel>
+          XML
+        end
+
+        let(:xml_with_standard) do
+          <<~XML
+            <CustomModel identifier="123">
+              <name>XML Model: Vase</name>
+              <color>BLUE</color>
+              <size>22</size>
+              <desc>XML Description: A beautiful ceramic vase</desc>
+            </CustomModel>
+          XML
+        end
+
+        it "handles bidirectional conversion with custom methods" do
+          model1 = MultipleMapping::CustomModel.from_xml(xml_with_alternate)
+          model2 = MultipleMapping::CustomModel.from_xml(xml_with_standard)
+
+          # Element names are 'name', 'color', 'size', 'desc' respectively since
+          # they are first element in their respective mapping array
+          expected_xml = <<~XML
+            <CustomModel id="XML-123">
+              <name>XML Model: Vase</name>
+              <color>BLUE</color>
+              <size>22</size>
+              <desc>XML Description: A beautiful ceramic vase</desc>
+            </CustomModel>
+          XML
+          expect(model1.to_xml).to be_equivalent_to(expected_xml)
+          expect(model2.to_xml).to be_equivalent_to(expected_xml)
+        end
+      end
+
+      context "with Nokogiri adapter" do
+        it_behaves_like "xml adapter with custom methods", Lutaml::Model::XmlAdapter::NokogiriAdapter
+      end
+
+      context "with Ox adapter" do
+        it_behaves_like "xml adapter with custom methods", Lutaml::Model::XmlAdapter::OxAdapter
+      end
+    end
+  end
+end

data/spec/lutaml/model/ordered_content_spec.rb

@@ -77,7 +77,7 @@ RSpec.describe "OrderedContent" do
     it_behaves_like "ordered content behavior", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OgaAdapter, skip: "Not implemented yet" do
+  describe Lutaml::Model::XmlAdapter::OgaAdapter do
     it_behaves_like "ordered content behavior", described_class
   end
 end

data/spec/lutaml/model/render_nil_spec.rb

@@ -42,6 +42,7 @@ class RenderNil < Lutaml::Model::Serializable
     map "clay_type", to: :clay_type, render_nil: false
     map "glaze", to: :glaze, render_nil: true
     map "dimensions", to: :dimensions, render_nil: false
+    map "render_nil_nested", to: :render_nil_nested, render_nil: false
   end
 
   toml do
@@ -59,8 +60,10 @@ RSpec.describe RenderNil do
       clay_type: nil,
       glaze: nil,
       dimensions: nil,
+      render_nil_nested: RenderNilNested.new,
     }
   end
+
   let(:model) { described_class.new(attributes) }
 
   it "serializes to JSON with render_nil option" do

data/spec/lutaml/model/root_mappings_spec.rb

@@ -0,0 +1,297 @@
+module RootMappingSpec
+  class CeramicDetails < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :insignia, :string
+
+    key_value do
+      map "name", to: :name
+      map "insignia", to: :insignia
+    end
+  end
+
+  class CeramicWithDetails < Lutaml::Model::Serializable
+    attribute :ceramic_id, :string
+    attribute :ceramic_type, :string
+    attribute :ceramic_details, CeramicDetails
+    attribute :ceramic_urn, :string
+
+    key_value do
+      map "id", to: :ceramic_id
+      map "type", to: :ceramic_type
+      map "details", to: :ceramic_details
+      map "urn", to: :ceramic_urn
+    end
+  end
+
+  class CeramicCollectionWithKeyAndValue < Lutaml::Model::Serializable
+    attribute :ceramics, CeramicWithDetails, collection: true
+
+    key_value do
+      map to: :ceramics,
+          root_mappings: {
+            ceramic_id: :key,
+            ceramic_details: :value,
+          }
+    end
+  end
+
+  class CeramicCollectionWithKeyAndComplexValue < Lutaml::Model::Serializable
+    attribute :ceramics, CeramicWithDetails, collection: true
+
+    key_value do
+      map to: :ceramics,
+          root_mappings: {
+            ceramic_id: :key,
+            ceramic_type: :type,
+            ceramic_details: "details",
+            ceramic_urn: ["urn", "primary"],
+          }
+    end
+  end
+
+  class Ceramic < Lutaml::Model::Serializable
+    attribute :ceramic_id, :string
+    attribute :ceramic_name, :string
+
+    key_value do
+      map "id", to: :ceramic_id
+      map "name", to: :ceramic_name
+    end
+  end
+
+  class CeramicCollectionWithKeyOnly < Lutaml::Model::Serializable
+    attribute :ceramics, Ceramic, collection: true
+
+    key_value do
+      map to: :ceramics, root_mappings: { ceramic_id: :key }
+    end
+  end
+
+  class CeramicCollectionWithoutCollectionTrue < Lutaml::Model::Serializable
+    attribute :ceramics, Ceramic
+
+    key_value do
+      map to: :ceramics, root_mappings: { ceramic_id: :key }
+    end
+  end
+end
+
+RSpec.describe "RootMapping" do
+  shared_examples "having root mappings" do |format|
+    let(:adapter) do
+      Lutaml::Model::Config.public_send(:"#{format}_adapter")
+    end
+
+    let(:input) do
+      adapter.new(input_hash).public_send(:"to_#{format}")
+    end
+
+    # 1. Only map to `:key`. Then only override key, the rest of the mappings stay.
+    context "when only `key` is mapped" do
+      let(:parsed) do
+        RootMappingSpec::CeramicCollectionWithKeyOnly.public_send(:"from_#{format}", input)
+      end
+
+      let(:input_hash) do
+        {
+          "vase1" => { "name" => "Imperial Vase" },
+          "bowl2" => { "name" => "18th Century Bowl" },
+        }
+      end
+
+      let(:ceramic_vase) do
+        RootMappingSpec::Ceramic.new(
+          ceramic_id: "vase1",
+          ceramic_name: "Imperial Vase",
+        )
+      end
+
+      let(:ceramic_bowl) do
+        RootMappingSpec::Ceramic.new(
+          ceramic_id: "bowl2",
+          ceramic_name: "18th Century Bowl",
+        )
+      end
+
+      it "parses" do
+        expect(parsed.ceramics.count).to eq(2)
+        # Because Tomlib reverses the order of the hash, so can not check based on position
+        expect(parsed.ceramics).to include(ceramic_vase)
+        expect(parsed.ceramics).to include(ceramic_bowl)
+      end
+
+      describe "serialize" do
+        let(:collection) do
+          RootMappingSpec::CeramicCollectionWithKeyOnly.new(ceramics: [
+                                                              ceramic_vase,
+                                                              ceramic_bowl,
+                                                            ])
+        end
+
+        it "serializes correctly" do
+          expect(collection.public_send(:"to_#{format}")).to eq(input)
+        end
+      end
+    end
+
+    # 2. Maps `:key` and another attribute, then we override all the other mappings (clean slate)
+    context "when `key` and `value` are mapped" do
+      let(:parsed) do
+        RootMappingSpec::CeramicCollectionWithKeyAndValue.public_send(:"from_#{format}", input)
+      end
+
+      let(:input_hash) do
+        {
+          "vase1" => { "name" => "Imperial Vase", "insignia" => "Tang Tianbao" },
+          "bowl2" => { "name" => "18th Century Bowl", "insignia" => "Ming Wanli" },
+        }
+      end
+
+      let(:vase_with_details) do
+        RootMappingSpec::CeramicWithDetails.new(
+          ceramic_id: "vase1",
+          ceramic_details: RootMappingSpec::CeramicDetails.new(
+            name: "Imperial Vase",
+            insignia: "Tang Tianbao",
+          ),
+        )
+      end
+
+      let(:bowl_with_details) do
+        RootMappingSpec::CeramicWithDetails.new(
+          ceramic_id: "bowl2",
+          ceramic_details: RootMappingSpec::CeramicDetails.new(
+            name: "18th Century Bowl",
+            insignia: "Ming Wanli",
+          ),
+        )
+      end
+
+      it "parses" do
+        expect(parsed.ceramics.count).to eq(2)
+        # Because Tomlib reverses the order of the hash, so can not check based on position
+        expect(parsed.ceramics).to include(vase_with_details)
+        expect(parsed.ceramics).to include(bowl_with_details)
+      end
+
+      describe "serialize" do
+        let(:collection) do
+          RootMappingSpec::CeramicCollectionWithKeyAndValue.new(ceramics: [
+                                                                  vase_with_details,
+                                                                  bowl_with_details,
+                                                                ])
+        end
+
+        it "serializes correctly" do
+          expect(collection.public_send(:"to_#{format}")).to eq(input)
+        end
+      end
+    end
+
+    # 3. Maps `:key` and `:value`, then we map the key and the value body to the new mappings.
+    context "when `key` and complex value structure is mapped" do
+      let(:parsed) do
+        RootMappingSpec::CeramicCollectionWithKeyAndComplexValue.public_send(:"from_#{format}", input)
+      end
+
+      let(:input_hash) do
+        {
+          "vase1" => {
+            "type" => "vase",
+            "details" => {
+              "name" => "Imperial Vase",
+              "insignia" => "Tang Tianbao",
+            },
+            "urn" => {
+              "primary" => "urn:ceramic:vase:vase1",
+            },
+          },
+          "bowl2" => {
+            "type" => "bowl",
+            "details" => {
+              "name" => "18th Century Bowl",
+              "insignia" => "Ming Wanli",
+            },
+            "urn" => {
+              "primary" => "urn:ceramic:bowl:bowl2",
+            },
+          },
+        }
+      end
+
+      let(:vase_with_details) do
+        RootMappingSpec::CeramicWithDetails.new(
+          ceramic_id: "vase1",
+          ceramic_type: "vase",
+          ceramic_urn: "urn:ceramic:vase:vase1",
+          ceramic_details: RootMappingSpec::CeramicDetails.new(
+            name: "Imperial Vase",
+            insignia: "Tang Tianbao",
+          ),
+        )
+      end
+
+      let(:bowl_with_details) do
+        RootMappingSpec::CeramicWithDetails.new(
+          ceramic_id: "bowl2",
+          ceramic_type: "bowl",
+          ceramic_urn: "urn:ceramic:bowl:bowl2",
+          ceramic_details: RootMappingSpec::CeramicDetails.new(
+            name: "18th Century Bowl",
+            insignia: "Ming Wanli",
+          ),
+        )
+      end
+
+      it "parses" do
+        expect(parsed.ceramics.count).to eq(2)
+        # Because Tomlib reverses the order of the hash, so can not check based on position
+        expect(parsed.ceramics).to include(vase_with_details)
+        expect(parsed.ceramics).to include(bowl_with_details)
+      end
+
+      describe "serialize from object" do
+        let(:collection) do
+          RootMappingSpec::CeramicCollectionWithKeyAndComplexValue.new(ceramics: [
+                                                                         vase_with_details,
+                                                                         bowl_with_details,
+                                                                       ])
+        end
+
+        it "serializes correctly" do
+          expect(collection.public_send(:"to_#{format}")).to eq(input)
+        end
+      end
+    end
+
+    context "when `collection: true` is missing" do
+      let(:input_hash) do
+        {
+          "vase1" => { "name" => "Imperial Vase" },
+          "bowl2" => { "name" => "18th Century Bowl" },
+        }
+      end
+
+      it "raises error" do
+        expect do
+          RootMappingSpec::CeramicCollectionWithoutCollectionTrue.public_send(:"from_#{format}", input)
+        end.to raise_error(
+          Lutaml::Model::CollectionTrueMissingError,
+          "May be `collection: true` is missing for `ceramics` in RootMappingSpec::CeramicCollectionWithoutCollectionTrue",
+        )
+      end
+    end
+  end
+
+  describe Lutaml::Model::YamlAdapter::StandardYamlAdapter do
+    it_behaves_like "having root mappings", :yaml
+  end
+
+  describe Lutaml::Model::JsonAdapter::StandardJsonAdapter do
+    it_behaves_like "having root mappings", :json
+  end
+
+  describe Lutaml::Model::TomlAdapter::TomlRbAdapter do
+    it_behaves_like "having root mappings", :toml
+  end
+end