lutaml-model 0.6.0 → 0.6.2

data/spec/lutaml/model/xml_adapter_spec.rb

@@ -33,146 +33,154 @@ module XmlAdapterSpec
   end
 end
 
-RSpec.shared_examples "an XML adapter" do |adapter_class|
-  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
-
-  before do
-    # Ensure BigDecimal is loaded because it is being used in sample model
-    require "bigdecimal"
-  end
-
-  let(:attributes) { { name: "John Doe", age: 30 } }
-  let(:model) { SampleModel.new(attributes) }
-
-  context "with default value" do
-    it "set display attribute correctly, other attributes default" do
-      xml = "<math display='true'></math>"
-
-      parsed = XmlAdapterSpec::Maths.from_xml(xml)
-      expect(parsed.display).to eq("true")
-      expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
-      expect(parsed.style.displaystyle).to eq("true")
+RSpec.describe "XmlAdapter" do
+  shared_examples "an XML adapter" do |adapter_class|
+    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
 
-    it "set style attribute correctly, other attributes default" do
-      xml = "<math> <mstyle displaystyle='false'>  </mstyle> </math>"
-
-      parsed = XmlAdapterSpec::Maths.from_xml(xml)
-      expect(parsed.display).to eq("block")
-      expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
-      expect(parsed.style.displaystyle).to eq("false")
-    end
-
-    it "sets attributes default values" do
-      xml = "<math> </math>"
-
-      parsed = XmlAdapterSpec::Maths.from_xml(xml)
-      expect(parsed.display).to eq("block")
-      expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
-      expect(parsed.style.displaystyle).to eq("true")
+    before do
+      # Ensure BigDecimal is loaded because it is being used in sample model
+      require "bigdecimal"
     end
 
-    it "delegate attributes with value" do
-      xml = "<math color='blue' finish='no'></math>"
-
-      parsed = XmlAdapterSpec::Maths.from_xml(xml)
-      expect(parsed.style.color).to eq("blue")
-      expect(parsed.style.finish).to eq("no")
-      expect(parsed.style.displaystyle).to eq("true")
+    let(:attributes) { { name: "John Doe", age: 30 } }
+    let(:model) { SampleModel.new(attributes) }
+
+    context "with default value" do
+      it "set display attribute correctly, other attributes default" do
+        xml = "<math display='true'></math>"
+
+        parsed = XmlAdapterSpec::Maths.from_xml(xml)
+        expect(parsed.display).to eq("true")
+        expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
+        expect(parsed.style.displaystyle).to eq("true")
+      end
+
+      it "set style attribute correctly, other attributes default" do
+        xml = "<math> <mstyle displaystyle='false'>  </mstyle> </math>"
+
+        parsed = XmlAdapterSpec::Maths.from_xml(xml)
+        expect(parsed.display).to eq("block")
+        expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
+        expect(parsed.style.displaystyle).to eq("false")
+      end
+
+      it "sets attributes default values" do
+        xml = "<math> </math>"
+
+        parsed = XmlAdapterSpec::Maths.from_xml(xml)
+        expect(parsed.display).to eq("block")
+        expect(parsed.style.class).to eq(XmlAdapterSpec::Mstyle)
+        expect(parsed.style.displaystyle).to eq("true")
+      end
+
+      it "delegate attributes with value" do
+        xml = "<math color='blue' finish='no'></math>"
+
+        parsed = XmlAdapterSpec::Maths.from_xml(xml)
+        expect(parsed.style.color).to eq("blue")
+        expect(parsed.style.finish).to eq("no")
+        expect(parsed.style.displaystyle).to eq("true")
+      end
+
+      it "delegate attributes with one value" do
+        xml = "<math color='blue'></math>"
+
+        parsed = XmlAdapterSpec::Maths.from_xml(xml)
+        expect(parsed.style.color).to eq("blue")
+        expect(parsed.style.finish).to eq("yes")
+        expect(parsed.style.displaystyle).to eq("true")
+      end
+
+      it "delegate attributes with no value" do
+        xml = "<math></math>"
+
+        parsed = XmlAdapterSpec::Maths.from_xml(xml)
+        expect(parsed.style.color).to be_nil
+        expect(parsed.style.finish).to eq("yes")
+        expect(parsed.style.displaystyle).to eq("true")
+      end
+
+      context "when round-trips" do
+        let(:parsed) do
+          XmlAdapterSpec::Maths.from_xml(xml)
+        end
+
+        let(:xml) do
+          "<math display='true'></math>"
+        end
+
+        let(:expected_xml) do
+          <<~XML
+            <math display="true" finish="yes">
+              <mstyle displaystyle="true"/>
+            </math>
+          XML
+        end
+
+        it "add default values" do
+          expect(parsed.to_xml.strip).to be_equivalent_to(expected_xml.strip)
+        end
+      end
     end
 
-    it "delegate attributes with one value" do
-      xml = "<math color='blue'></math>"
+    it "serializes to XML" do
+      expected_xml = <<~XML
+        <SampleModel>
+          <Name>John Doe</Name>
+          <Age>30</Age>
+        </SampleModel>
+      XML
 
-      parsed = XmlAdapterSpec::Maths.from_xml(xml)
-      expect(parsed.style.color).to eq("blue")
-      expect(parsed.style.finish).to eq("yes")
-      expect(parsed.style.displaystyle).to eq("true")
+      doc = adapter_class.parse(expected_xml)
+      xml = doc.to_xml
+      expect(xml).to be_equivalent_to(expected_xml)
     end
 
-    it "delegate attributes with no value" do
-      xml = "<math></math>"
+    it "serializes to XML with only content" do
+      expected_xml = <<~XML
+        <Tag>
+          Bug
+        </Tag>
+      XML
 
-      parsed = XmlAdapterSpec::Maths.from_xml(xml)
-      expect(parsed.style.color).to be_nil
-      expect(parsed.style.finish).to eq("yes")
-      expect(parsed.style.displaystyle).to eq("true")
+      doc = SampleModelTag.from_xml(expected_xml)
+      xml = doc.to_xml
+      expect(xml).to be_equivalent_to(expected_xml)
     end
 
-    it "round-trips XML and add default values" do
-      input_xml = <<~XML
-        <math display='true'></math>
-      XML
-
-      output_xml = <<~XML
-        <math display="true" finish="yes">
-          <mstyle displaystyle="true"/>
-        </math>
+    it "deserializes from XML" do
+      xml = <<~XML
+        <SampleModel>
+          <Name>John Doe</Name>
+          <Age>30</Age>
+        </SampleModel>
       XML
 
-      parsed = XmlAdapterSpec::Maths.from_xml(input_xml)
-
-      expect(parsed.to_xml.strip).to be_equivalent_to(output_xml.strip)
+      doc = adapter_class.parse(xml)
+      new_model = SampleModel.new(doc.root.children.to_h do |child|
+        [child.name.downcase.to_sym, child.text]
+      end)
+      expect(new_model.name).to eq("John Doe")
+      expect(new_model.age).to eq(30)
     end
   end
 
-  it "serializes to XML" do
-    expected_xml = <<~XML
-      <SampleModel>
-        <Name>John Doe</Name>
-        <Age>30</Age>
-      </SampleModel>
-    XML
-
-    doc = adapter_class.parse(expected_xml)
-    xml = doc.to_xml
-    expect(xml).to be_equivalent_to(expected_xml)
+  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+    it_behaves_like "an XML adapter", described_class
   end
 
-  it "serializes to XML with only content" do
-    expected_xml = <<~XML
-      <Tag>
-        Bug
-      </Tag>
-    XML
-
-    doc = SampleModelTag.from_xml(expected_xml)
-    xml = doc.to_xml
-    expect(xml).to be_equivalent_to(expected_xml)
+  describe Lutaml::Model::XmlAdapter::OxAdapter do
+    it_behaves_like "an XML adapter", described_class
   end
 
-  it "deserializes from XML" do
-    xml = <<~XML
-      <SampleModel>
-        <Name>John Doe</Name>
-        <Age>30</Age>
-      </SampleModel>
-    XML
-
-    doc = adapter_class.parse(xml)
-    new_model = SampleModel.new(doc.root.children.to_h do |child|
-      [child.name.downcase.to_sym, child.text]
-    end)
-    expect(new_model.name).to eq("John Doe")
-    expect(new_model.age).to eq(30)
+  describe Lutaml::Model::XmlAdapter::OgaAdapter do
+    it_behaves_like "an XML adapter", described_class
   end
 end
-
-RSpec.describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
-  it_behaves_like "an XML adapter", described_class
-end
-
-RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
-  it_behaves_like "an XML adapter", described_class
-end
-
-RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
-  it_behaves_like "an XML adapter", described_class
-end

data/spec/lutaml/model/xml_mapping_spec.rb

@@ -57,6 +57,7 @@ module XmlMapping
   class Address < Lutaml::Model::Serializable
     attribute :street, ::Lutaml::Model::Type::String, raw: true
     attribute :city, :string, raw: true
+    attribute :text, :string
     attribute :address, Address
 
     xml do
@@ -64,6 +65,7 @@ module XmlMapping
 
       map_element "street", to: :street
       map_element "city", to: :city
+      map_element "text", to: :text
     end
   end
 
@@ -334,7 +336,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
 
     let(:mapping) { Lutaml::Model::XmlMapping.new }
 
-    context "attribute namespace" do
+    context "with attribute having namespace" do
       input_xml = <<~XML
         <ns1:example ex1:alpha="hello"
                      beta="bye"
@@ -352,7 +354,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
       end
     end
 
-    context "explicit namespace" do
+    context "with explicit namespace" do
       mml = <<~XML
         <math xmlns="http://www.w3.org/1998/Math/MathML">
           <mfenced open="("></mfenced>
@@ -366,7 +368,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::OxAdapter do
+    context "when overriding child namespace prefix", skip: adapter_class == Lutaml::Model::XmlAdapter::OxAdapter do
       let(:input_xml) do
         <<~XML
           <OverrideDefaultNamespacePrefix
@@ -838,6 +840,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
                 <p>adf</p>
               </street>
               <city><a>M</a></city>
+              <text>Building near ABC</text>
             </address>
           </person>
         XML
@@ -859,6 +862,27 @@ RSpec.describe Lutaml::Model::XmlMapping do
       end
     end
 
+    context "with element named `text`" do
+      let(:input_xml) do
+        <<~XML
+          <address>
+            <street>
+              <a>N</a>
+              <p>adf</p>
+            </street>
+            <city><a>M</a></city>
+            <text>Building near ABC</text>
+          </address>
+        XML
+      end
+
+      let(:model) { XmlMapping::Address.from_xml(input_xml) }
+
+      it "expect to contain raw xml" do
+        expect(model.text).to eq("Building near ABC")
+      end
+    end
+
     context "with content mapping" do
       let(:xml_data) { "<i>my text <b>bold</b> is in italics</i>" }
       let(:italic) { Italic.from_xml(xml_data) }
@@ -1083,23 +1107,30 @@ RSpec.describe Lutaml::Model::XmlMapping do
         end
       end
 
-      it "maps all the content including tags" do
-        inner_xml = if adapter_class.type == "ox"
-                      "Str<sub>2</sub> text<sup>1</sup> 123"
-                    else
-                      "Str<sub>2</sub>text<sup>1</sup>123"
-                    end
-        xml = "<WithMapAll>#{inner_xml}</WithMapAll>"
+      context "without custom methods" do
+        let(:inner_xml) do
+          if adapter_class.type == "ox"
+            "Str<sub>2</sub> text<sup>1</sup> 123"
+          else
+            "Str<sub>2</sub>text<sup>1</sup>123"
+          end
+        end
 
-        parsed = XmlMapping::WithMapAll.from_xml(xml)
+        let(:xml) do
+          "<WithMapAll>#{inner_xml}</WithMapAll>"
+        end
 
-        expect(parsed.all_content).to eq(inner_xml)
-      end
+        let(:parsed) do
+          XmlMapping::WithMapAll.from_xml(xml)
+        end
 
-      it "round-trips xml" do
-        xml = "<WithMapAll>Str<sub>2</sub>text<sup>1</sup>123</WithMapAll>"
+        it "maps all the content including tags" do
+          expect(parsed.all_content).to eq(inner_xml)
+        end
 
-        expect(XmlMapping::WithMapAll.from_xml(xml).to_xml.chomp).to eq(xml)
+        it "round-trips xml" do
+          expect(parsed.to_xml.chomp).to eq(xml)
+        end
       end
 
       context "when nested content has map_all" do

data/spec/person_spec.rb

@@ -29,6 +29,7 @@ RSpec.describe Person do
       "active" => true,
     }
   end
+
   let(:attributes_json) do
     {
       firstName: "John",
@@ -42,8 +43,8 @@ RSpec.describe Person do
     }
   end
 
-  it "serializes to XML" do
-    expected_xml = <<~XML
+  let(:xml) do
+    <<~XML
       <p:Person xmlns:p="http://example.com/person" xmlns:nsp1="http://example.com/nsp1">
         <nsp1:FirstName>John</nsp1:FirstName>
         <nsp1:LastName>Doe</nsp1:LastName>
@@ -55,24 +56,13 @@ RSpec.describe Person do
         <p:Active>true</p:Active>
       </p:Person>
     XML
+  end
 
-    expect(model.to_xml).to be_equivalent_to(expected_xml)
+  it "serializes to XML" do
+    expect(model.to_xml).to be_equivalent_to(xml)
   end
 
   it "deserializes from XML" do
-    xml = <<~XML
-      <p:Person xmlns:p="http://example.com/person" xmlns:nsp1="http://example.com/nsp1">
-        <nsp1:FirstName>John</nsp1:FirstName>
-        <nsp1:LastName>Doe</nsp1:LastName>
-        <p:Age>30</p:Age>
-        <p:Height>5.9</p:Height>
-        <p:Birthdate>1990-01-01</p:Birthdate>
-        <p:LastLogin>2023-06-08T10:00:00+00:00</p:LastLogin>
-        <p:WakeupTime>07:00:00</p:WakeupTime>
-        <p:Active>true</p:Active>
-      </p:Person>
-    XML
-
     person = described_class.from_xml(xml)
     expect(person.first_name).to eq("John")
     expect(person.age).to eq(30)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64