lutaml-model 0.5.0 → 0.5.1

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

data/spec/lutaml/model/serializable_spec.rb

@@ -77,6 +77,25 @@ module SerializeableSpec
   class GlazeTechnique < Lutaml::Model::Serializable
     attribute :name, :string, values: ["Celadon", "Raku", "Majolica"]
   end
+
+  class TranslateHelper < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :path, :string
+    attribute :name, :string
+  end
+
+  class TranslateMappings < Lutaml::Model::Serializable
+    attribute :translate, TranslateHelper, collection: true
+
+    key_value do
+      map "translate", to: :translate, child_mappings:
+                                        {
+                                          id: :key,
+                                          path: %i[path link],
+                                          name: %i[path name],
+                                        }
+    end
+  end
 end
 
 RSpec.describe Lutaml::Model::Serializable do
@@ -173,7 +192,7 @@ RSpec.describe Lutaml::Model::Serializable do
     end
   end
 
-  describe ".apply_child_mappings" do
+  describe ".translate_mappings" do
     let(:child_mappings) do
       {
         id: :key,
@@ -205,17 +224,33 @@ RSpec.describe Lutaml::Model::Serializable do
       }
     end
 
+    let(:attr) { SerializeableSpec::TranslateMappings.attributes[:translate] }
+
     let(:expected_value) do
       [
-        { id: "foo", path: "link one", name: "one" },
-        { id: "abc", path: "link two", name: "two" },
-        { id: "hello", path: "link three", name: "three" },
+        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
-      expect(described_class.apply_child_mappings(hash,
-                                                  child_mappings)).to eq(expected_value)
+      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
 

data/spec/lutaml/model/with_child_mapping_spec.rb

@@ -37,6 +37,63 @@ module ChildMapping
                      }
     end
   end
+
+  class JS < Lutaml::Model::Serializable
+    attribute :prop, :string
+    attribute :hook, :string
+
+    key_value do
+      map :prop, to: :prop
+      map :hook, to: :hook
+    end
+  end
+
+  class Symbol < Lutaml::Model::Serializable
+    attribute :ascii, :string
+    attribute :html, :string
+    attribute :latex, :string
+    attribute :unicode, :string
+    attribute :js, JS
+
+    key_value do
+      map :ascii, to: :ascii
+      map :html, to: :html
+      map :latex, to: :latex
+      map :unicode, to: :unicode
+      map :js, to: :js
+    end
+  end
+
+  class Prefix < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :name, :string
+    attribute :symbol, Symbol
+    attribute :base, :integer
+    attribute :power, :integer
+
+    key_value do
+      map :prefix_id, to: :id
+      map :name, to: :name
+      map :symbol, to: :symbol
+      map :base, to: :base
+      map :power, to: :power
+    end
+  end
+
+  class Prefixes < Lutaml::Model::Serializable
+    attribute :prefixes, Prefix, collection: true
+
+    key_value do
+      map "prefixes", to: :prefixes, child_mappings:
+                                      {
+                                        id: :key,
+                                        name: :name,
+                                        symbol: :symbol,
+                                        base: :base,
+                                        power: :power,
+                                      }
+    end
+  end
 end
 
 RSpec.describe ChildMapping do
@@ -72,11 +129,52 @@ RSpec.describe ChildMapping do
   let(:expected_paths) { ["link one", "link two", "link three"] }
   let(:expected_names) { ["one", "two", "three"] }
 
+  let(:prefixes_hash) do
+    {
+      "prefixes" => {
+        "NISTp10_30" => {
+          "name" => "quetta",
+          "symbol" => {
+            "ascii" => "Q",
+            "html" => "Q",
+            "latex" => "Q",
+            "unicode" => "Q",
+            "js" => {
+              "prop" => "head",
+              "hook" => "async",
+            },
+          },
+          "base" => 10,
+          "power" => 30,
+        },
+        "NISTp10_27" => {
+          "name" => "ronna",
+          "symbol" => {
+            "ascii" => "R",
+            "html" => "R",
+            "latex" => "R",
+            "unicode" => "R",
+            "js" => {
+              "prop" => "head",
+              "hook" => "async",
+            },
+          },
+          "base" => 10,
+          "power" => 27,
+        },
+      },
+    }
+  end
+
   context "with json" do
     let(:json) do
       hash.to_json
     end
 
+    let(:prefixes_json) do
+      prefixes_hash.to_json
+    end
+
     describe ".from_json" do
       it "create model according to json" do
         instance = mapper.from_json(json)
@@ -86,6 +184,14 @@ RSpec.describe ChildMapping do
         expect(instance.schemas.map(&:path)).to eq(expected_paths)
         expect(instance.schemas.map(&:name)).to eq(expected_names)
       end
+
+      it "create model according to json with nesting values" do
+        instance = ChildMapping::Prefixes.from_json(prefixes_json)
+
+        expect(instance.prefixes.first.id).to eq("NISTp10_30")
+        expect(instance.prefixes.first.symbol.ascii).to eq("Q")
+        expect(instance.prefixes.first.symbol.js.hook).to eq("async")
+      end
     end
 
     describe ".to_json" do
@@ -98,6 +204,13 @@ RSpec.describe ChildMapping do
 
         expect(instance.to_json).to eq(json)
       end
+
+      it "converts object to json with nesting values" do
+        instance = ChildMapping::Prefixes.from_json(prefixes_json)
+        serialized = instance.to_json
+
+        expect(serialized).to be_equivalent_to(prefixes_json)
+      end
     end
   end
 
@@ -106,6 +219,10 @@ RSpec.describe ChildMapping do
       hash.to_yaml
     end
 
+    let(:prefixes_yaml) do
+      prefixes_hash.to_yaml
+    end
+
     describe ".from_yaml" do
       it "create model according to yaml" do
         instance = mapper.from_yaml(yaml)
@@ -115,6 +232,14 @@ RSpec.describe ChildMapping do
         expect(instance.schemas.map(&:path)).to eq(expected_paths)
         expect(instance.schemas.map(&:name)).to eq(expected_names)
       end
+
+      it "create model according to yaml with nesting values" do
+        instance = ChildMapping::Prefixes.from_yaml(prefixes_yaml)
+
+        expect(instance.prefixes.first.id).to eq("NISTp10_30")
+        expect(instance.prefixes.first.symbol.ascii).to eq("Q")
+        expect(instance.prefixes.first.symbol.js.hook).to eq("async")
+      end
     end
 
     describe ".to_yaml" do
@@ -127,6 +252,13 @@ RSpec.describe ChildMapping do
 
         expect(instance.to_yaml).to eq(yaml)
       end
+
+      it "converts object to yaml with nesting values" do
+        instance = ChildMapping::Prefixes.from_yaml(prefixes_yaml)
+        serialized = instance.to_yaml
+
+        expect(YAML.safe_load(serialized)).to eq(YAML.safe_load(prefixes_yaml))
+      end
     end
   end
 
@@ -145,6 +277,40 @@ RSpec.describe ChildMapping do
       TOML
     end
 
+    let(:prefixes_toml) do
+      <<~TOML
+        [prefixes.NISTp10_30]
+        name = "quetta"
+        base = 10
+        power = 30
+
+        [prefixes.NISTp10_30.symbol]
+        ascii = "Q"
+        html = "Q"
+        latex = "Q"
+        unicode = "Q"
+
+        [prefixes.NISTp10_30.symbol.js]
+        prop = "head"
+        hook = "async"
+
+        [prefixes.NISTp10_27]
+        name = "ronna"
+        base = 10
+        power = 27
+
+        [prefixes.NISTp10_27.symbol]
+        ascii = "R"
+        html = "R"
+        latex = "R"
+        unicode = "R"
+
+        [prefixes.NISTp10_27.symbol.js]
+        prop = "head"
+        hook = "async"
+      TOML
+    end
+
     describe ".from_toml" do
       it "create model according to toml" do
         instance = mapper.from_toml(toml)
@@ -154,6 +320,14 @@ RSpec.describe ChildMapping do
         expect(instance.schemas.map(&:path)).to eq(expected_paths)
         expect(instance.schemas.map(&:name)).to eq(expected_names)
       end
+
+      it "create model according to toml with nesting values" do
+        instance = ChildMapping::Prefixes.from_toml(prefixes_toml)
+
+        expect(instance.prefixes.first.id).to eq("NISTp10_30")
+        expect(instance.prefixes.first.symbol.ascii).to eq("Q")
+        expect(instance.prefixes.first.symbol.js.hook).to eq("async")
+      end
     end
 
     describe ".to_toml" do
@@ -169,6 +343,14 @@ RSpec.describe ChildMapping do
 
         expect(actual.attributes).to eq(expected.attributes)
       end
+
+      it "converts object to toml with nesting values" do
+        instance = ChildMapping::Prefixes.from_toml(prefixes_toml)
+        actual = Lutaml::Model::Config.toml_adapter.parse(instance.to_toml)
+        expected = Lutaml::Model::Config.toml_adapter.parse(prefixes_toml)
+
+        expect(actual.attributes).to eq(expected.attributes)
+      end
     end
   end
 end

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

@@ -86,6 +86,43 @@ RSpec.shared_context "XML namespace models" do
                                                   prefix: nil
     end
   end
+
+  class Body < Lutaml::Model::Serializable
+    attribute :paragraph, :string
+
+    xml do
+      map_element "p", to: :paragraph
+    end
+  end
+
+  class Element < Lutaml::Model::Serializable
+    attribute :text, :string
+    xml do
+      root "test-element"
+      namespace "http://www.test.com/schemas/test/1.0/", "test"
+      map_content to: :text
+    end
+  end
+
+  class Front < Lutaml::Model::Serializable
+    attribute :test_element, Element
+
+    xml do
+      namespace "http://www.test.com/schemas/test/1.0/", "test"
+      map_element "test-element", to: :test_element
+    end
+  end
+
+  class Article < Lutaml::Model::Serializable
+    attribute :front, Front
+    attribute :body, Body
+
+    xml do
+      root "article"
+      map_element "front", to: :front, prefix: "test", namespace: "http://www.test.com/schemas/test/1.0/"
+      map_element "body", to: :body
+    end
+  end
 end
 
 RSpec.shared_examples "XML serialization with namespace" do |model_class, xml_string|
@@ -236,6 +273,35 @@ RSpec.shared_examples "an XML namespace parser" do |adapter_class|
       expect(generated_xml).to be_equivalent_to(xml)
     end
   end
+
+  context "when custom namespace is used" do
+    let(:xml_input) do
+      <<~XML
+        <article xmlns:test="http://www.test.com/schemas/test/1.0/">
+          <test:front>
+            <test:test-element>Text Here</test:test-element>
+          </test:front>
+          <body>
+            <p>This is a paragraph</p>
+          </body>
+        </article>
+      XML
+    end
+
+    describe "XML serialization" do
+      it "correctly deserializes from XML" do
+        article = Article.from_xml(xml_input)
+        expect(article.body.paragraph).to eq("This is a paragraph")
+      end
+
+      it "round-trips XML" do
+        article = Article.from_xml(xml_input)
+        output_xml = article.to_xml(pretty: true)
+
+        expect(output_xml).to be_equivalent_to(xml_input)
+      end
+    end
+  end
 end
 
 RSpec.describe Lutaml::Model::XmlAdapter::NokogiriAdapter do