lutaml-model 0.4.0 → 0.5.0

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

@@ -87,7 +87,7 @@ RSpec.describe Lutaml::Model::Serializable do
       end.to change(
         described_class, :model
       )
-        .from(nil)
+        .from(described_class)
         .to(SerializeableSpec::TestModel)
     end
   end

data/spec/lutaml/model/type/boolean_spec.rb

@@ -1,5 +1,23 @@
 require "spec_helper"
 
+module BooleanSpec
+  class Employee < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :full_time, :boolean
+    attribute :on_leave, :boolean
+    attribute :remote, :boolean
+    attribute :active, :boolean
+
+    key_value do
+      map "name", to: :name
+      map "full_time", to: :full_time
+      map "on_leave", to: :on_leave
+      map "remote", to: :remote, render_nil: true
+      map "active", to: :active, render_nil: false
+    end
+  end
+end
+
 RSpec.describe Lutaml::Model::Type::Boolean do
   describe ".cast" do
     let(:truthy_values) { [true, "true", "t", "yes", "y", "1"] }
@@ -51,4 +69,48 @@ RSpec.describe Lutaml::Model::Type::Boolean do
       expect(described_class.serialize(true)).to be true
     end
   end
+
+  context "with key-value serialization" do
+    let(:yaml) do
+      {
+        "name" => "John Smith",
+        "full_time" => true,
+        "on_leave" => false,
+        "remote" => nil,
+        "active" => nil,
+      }.to_yaml
+    end
+
+    let(:expected_yaml) do
+      {
+        "name" => "John Smith",
+        "full_time" => true,
+        "on_leave" => false,
+        "remote" => nil,
+      }.to_yaml
+    end
+
+    it "deserializes boolean values correctly" do
+      employee = BooleanSpec::Employee.from_yaml(yaml)
+
+      expect(employee.name).to eq("John Smith")
+      expect(employee.full_time).to be true
+      expect(employee.on_leave).to be false
+      expect(employee.remote).to be_nil
+      expect(employee.active).to be_nil
+    end
+
+    it "serializes boolean values correctly" do
+      employee = BooleanSpec::Employee.new(
+        name: "John Smith",
+        full_time: true,
+        on_leave: false,
+        remote: nil,
+        active: nil,
+      )
+
+      yaml_output = employee.to_yaml
+      expect(yaml_output).to eq(expected_yaml)
+    end
+  end
 end

data/spec/lutaml/model/xml_adapter/oga_adapter_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "oga"
 require_relative "../../../../lib/lutaml/model/xml_adapter/oga_adapter"
 
-RSpec.xdescribe Lutaml::Model::XmlAdapter::OgaAdapter do
+RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
   let(:xml_string) do
     <<~XML
       <root xmlns="http://example.com/default" xmlns:prefix="http://example.com/prefixed">
@@ -14,21 +14,21 @@ RSpec.xdescribe Lutaml::Model::XmlAdapter::OgaAdapter do
   let(:document) { described_class.parse(xml_string) }
 
   context "parsing XML with namespaces" do
+    let(:child) { document.root.children[1] }
+
     it "parses the root element with default namespace" do
       expect(document.root.name).to eq("root")
-      expect(document.root.namespace).to eq("http://example.com/default")
-      expect(document.root.namespace_prefix).to be_nil
+      expect(document.root.namespace.uri).to eq("http://example.com/default")
+      expect(document.root.namespace.prefix).to be_nil
     end
 
     it "parses child element with prefixed namespace" do
-      child = document.root.children.first
-      expect(child.name).to eq("child")
-      expect(child.namespace).to eq("http://example.com/prefixed")
-      expect(child.namespace_prefix).to eq("prefix")
+      expect(child.name).to eq("prefix:child")
+      expect(child.namespace.uri).to eq("http://example.com/prefixed")
+      expect(child.namespace.prefix).to eq("prefix")
     end
 
     it "parses attributes with and without namespaces" do
-      child = document.root.children.first
       expect(child.attributes["attr"].value).to eq("value")
       expect(child.attributes["attr"].namespace).to be_nil
       expect(child.attributes["prefix:attr"].value).to eq("prefixed_value")
@@ -42,12 +42,12 @@ RSpec.xdescribe Lutaml::Model::XmlAdapter::OgaAdapter do
       xml_output = document.to_xml
       parsed_output = Oga.parse_xml(xml_output)
 
-      root = parsed_output.root
+      root = parsed_output.children.first
       expect(root.name).to eq("root")
       expect(root.namespace.uri).to eq("http://example.com/default")
 
-      child = root.children.first
-      expect(child.name).to eq("child")
+      child = root.children[1]
+      expect(child.expanded_name).to eq("prefix:child")
       expect(child.namespace.uri).to eq("http://example.com/prefixed")
       expect(child.get("attr")).to eq("value")
       expect(child.get("prefix:attr")).to eq("prefixed_value")

data/spec/lutaml/model/xml_adapter/xml_namespace_spec.rb

@@ -246,6 +246,6 @@ RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
   it_behaves_like "an XML namespace parser", described_class
 end
 
-RSpec.xdescribe Lutaml::Model::XmlAdapter::OgaAdapter do
+RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
   it_behaves_like "an XML namespace parser", described_class
 end

data/spec/lutaml/model/xml_adapter_spec.rb

@@ -119,7 +119,7 @@ RSpec.shared_examples "an XML adapter" do |adapter_class|
 
       parsed = XmlAdapterSpec::Maths.from_xml(input_xml)
 
-      expect(parsed.to_xml.strip).to eq(output_xml.strip)
+      expect(parsed.to_xml.strip).to be_equivalent_to(output_xml.strip)
     end
   end
 
@@ -173,6 +173,6 @@ RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
   it_behaves_like "an XML adapter", described_class
 end
 
-RSpec.xdescribe Lutaml::Model::XmlAdapter::OgaAdapter do
+RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
   it_behaves_like "an XML adapter", described_class
 end

data/spec/lutaml/model/xml_mapping_spec.rb

@@ -325,7 +325,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
     end
 
     # Skipping for OX because it does not handle namespaces
-    context "overriding child namespace prefix", skip: adapter_class != Lutaml::Model::XmlAdapter::NokogiriAdapter do
+    context "overriding child namespace prefix", skip: adapter_class == Lutaml::Model::XmlAdapter::OxAdapter do
       let(:input_xml) do
         <<~XML
           <OverrideDefaultNamespacePrefix
@@ -342,9 +342,20 @@ RSpec.describe Lutaml::Model::XmlMapping do
         XML
       end
 
+      let(:oga_expected_xml) do
+        "<OverrideDefaultNamespacePrefix xmlns:abc=\"http://www.omg.org/spec/XMI/20131001\">" +
+          "<abc:SameElementName App=\"hello\" xmlns:GML=\"http://www.sparxsystems.com/profiles/GML/1.0\" xmlns:CityGML=\"http://www.sparxsystems.com/profiles/CityGML/1.0\">" +
+          "<GML:ApplicationSchema>GML App</GML:ApplicationSchema>" +
+          "<CityGML:ApplicationSchema>CityGML App</CityGML:ApplicationSchema>" +
+          "<abc:ApplicationSchema>App</abc:ApplicationSchema>" +
+          "</abc:SameElementName>" +
+          "</OverrideDefaultNamespacePrefix>"
+      end
+
       it "expect to round-trips" do
         parsed = XmlMapping::OverrideDefaultNamespacePrefix.from_xml(input_xml)
-        expect(parsed.to_xml).to be_equivalent_to(input_xml)
+        expected_xml = adapter_class.type == "oga" ? oga_expected_xml : input_xml
+        expect(parsed.to_xml).to be_equivalent_to(expected_xml)
       end
     end
 
@@ -379,6 +390,15 @@ RSpec.describe Lutaml::Model::XmlMapping do
             "ApplicationSchema",
             "ApplicationSchema",
           ],
+          Lutaml::Model::XmlAdapter::OgaAdapter => [
+            "text",
+            "ApplicationSchema",
+            "text",
+            "ApplicationSchema",
+            "text",
+            "ApplicationSchema",
+            "text",
+          ],
         }
       end
 
@@ -1032,12 +1052,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
         end
 
         it "round-trips xml" do
-          expected_xml = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
-                           expected_nokogiri_xml
-                         else
-                           expected_ox_xml
-                         end
-
+          expected_xml = adapter_class.type == "ox" ? expected_ox_xml : expected_nokogiri_xml
           expect(XmlMapping::SpecialCharContentWithMapAll.from_xml(xml).to_xml).to eq(expected_xml)
         end
       end
@@ -1066,7 +1081,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
     it_behaves_like "having XML Mappings", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OgaAdapter, skip: "Not implemented yet" do
+  describe Lutaml::Model::XmlAdapter::OgaAdapter do
     it_behaves_like "having XML Mappings", described_class
   end
 end