lutaml-model 0.4.0 → 0.5.1

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
@@ -87,7 +106,7 @@ RSpec.describe Lutaml::Model::Serializable do
       end.to change(
         described_class, :model
       )
-        .from(nil)
+        .from(described_class)
         .to(SerializeableSpec::TestModel)
     end
   end
@@ -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/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/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/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

@@ -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
@@ -246,6 +312,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
 
@@ -600,6 +620,14 @@ RSpec.describe Lutaml::Model::XmlMapping do
         it "contain schemaLocation attributes" do
           expect(Paragraph.from_xml(xml).to_xml).to be_equivalent_to(xml)
         end
+
+        it "prints warning if defined explicitly in class" do
+          error_regex = /\[Lutaml::Model\] WARN: `schemaLocation` is handled by default\. No need to explecitly define at `xml_mapping_spec.rb:\d+`/
+
+          expect do
+            Lutaml::Model::XmlMapping.new.map_attribute("schemaLocation", to: :schema_location)
+          end.to output(error_regex).to_stderr
+        end
       end
 
       context "when mixed: true" do
@@ -1032,12 +1060,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 +1089,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