lutaml-model 0.5.3 → 0.6.0

data/spec/lutaml/model/xml_mapping_spec.rb

@@ -131,6 +131,45 @@ module XmlMapping
     end
   end
 
+  class AnnotatedElement < Lutaml::Model::Serializable
+    attribute :idref, :string
+
+    xml do
+      root "annotatedElement"
+      map_attribute "idref", to: :idref, namespace: "http://www.omg.org/spec/XMI/20131001", prefix: "xmi"
+    end
+  end
+
+  class OwnedComment < Lutaml::Model::Serializable
+    attribute :annotated_attribute, :string
+    attribute :annotated_element, AnnotatedElement
+
+    xml do
+      root "ownedComment"
+      map_attribute "annotatedElement", to: :annotated_attribute
+      map_element "annotatedElement", to: :annotated_element, prefix: nil, namespace: nil
+    end
+  end
+
+  class Date < Lutaml::Model::Serializable
+    attribute :type, :string
+    attribute :text, :string
+    attribute :content, :string
+    attribute :from, :string
+    attribute :to, :string
+    attribute :on, :string
+
+    xml do
+      root "date", mixed: true
+      map_attribute "type", to: :type
+      map_attribute "text", to: :text
+      map_content to: :content
+      map_element "from", to: :from
+      map_element "to", to: :to
+      map_element "on", to: :on
+    end
+  end
+
   class OverrideDefaultNamespacePrefix < Lutaml::Model::Serializable
     attribute :same_element_name, SameNameDifferentNamespace
 
@@ -187,7 +226,8 @@ module XmlMapping
     xml do
       root "MapAllWithCustomMethod"
 
-      map_all to: :all_content, with: { to: :content_to_xml, from: :content_from_xml }
+      map_all_content to: :all_content,
+                      with: { to: :content_to_xml, from: :content_from_xml }
     end
 
     def content_to_xml(model, parent, doc)
@@ -305,6 +345,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
 
       it "checks the attribute with and without namespace" do
         parsed = XmlMapping::AttributeNamespace.from_xml(input_xml)
+
         expect(parsed.alpha).to eq("hello")
         expect(parsed.beta).to eq("bye")
         expect(parsed.to_xml).to be_equivalent_to(input_xml)
@@ -343,12 +384,12 @@ RSpec.describe Lutaml::Model::XmlMapping do
       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 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
 
@@ -359,6 +400,69 @@ RSpec.describe Lutaml::Model::XmlMapping do
       end
     end
 
+    context "with same element and attribute name" do
+      let(:xml_with_element) do
+        <<~XML
+          <ownedComment xmlns:xmi="http://www.omg.org/spec/XMI/20131001">
+            <annotatedElement xmi:idref="ABC"/>
+          </ownedComment>
+        XML
+      end
+
+      let(:xml_with_attribute) do
+        <<~XML
+          <ownedComment annotatedElement="test2">
+          </ownedComment>
+        XML
+      end
+
+      let(:xml_with_same_name_attribute_and_element) do
+        <<~XML
+          <ownedComment xmlns:xmi="http://www.omg.org/spec/XMI/20131001" annotatedElement="test2">
+            <annotatedElement xmi:idref="ABC"/>
+          </ownedComment>
+        XML
+      end
+
+      let(:xml) do
+        <<~XML
+          <date type="published">
+            End of December
+            <on>2020-01</on>
+            Start of January
+          </date>
+        XML
+      end
+
+      it "parse and serializes the input xml correctly # lutaml/issues/217" do
+        parsed = XmlMapping::OwnedComment.from_xml(xml_with_element)
+        serialized = parsed.to_xml
+
+        expect(serialized).to be_equivalent_to(xml_with_element.strip)
+      end
+
+      it "parse and serialize model correctly" do
+        parsed = XmlMapping::OwnedComment.from_xml(xml_with_attribute)
+        serialized = parsed.to_xml
+
+        expect(serialized).to be_equivalent_to(xml_with_attribute)
+      end
+
+      it "parse and serialize model correctly with both attribute and element" do
+        parsed = XmlMapping::OwnedComment.from_xml(xml_with_same_name_attribute_and_element)
+        serialized = parsed.to_xml
+
+        expect(serialized).to be_equivalent_to(xml_with_same_name_attribute_and_element)
+      end
+
+      it "testing parse element" do
+        parsed = XmlMapping::Date.from_xml(xml)
+        serialized = parsed.to_xml
+
+        expect(serialized).to be_equivalent_to(xml)
+      end
+    end
+
     context "with same name elements" do
       let(:input_xml) do
         <<~XML
@@ -375,34 +479,38 @@ RSpec.describe Lutaml::Model::XmlMapping do
       end
 
       let(:expected_order) do
+        nokogiri_pattern = create_pattern_mapping([
+                                                    ["Text", "text"],
+                                                    ["Element", "ApplicationSchema"],
+                                                    ["Text", "text"],
+                                                    ["Element", "ApplicationSchema"],
+                                                    ["Text", "text"],
+                                                    ["Element", "ApplicationSchema"],
+                                                    ["Text", "text"],
+                                                  ])
+
+        oga_ox_pattern = create_pattern_mapping([
+                                                  ["Element", "ApplicationSchema"],
+                                                  ["Element", "ApplicationSchema"],
+                                                  ["Element", "ApplicationSchema"],
+                                                ])
+
         {
-          Lutaml::Model::XmlAdapter::NokogiriAdapter => [
-            "text",
-            "ApplicationSchema",
-            "text",
-            "ApplicationSchema",
-            "text",
-            "ApplicationSchema",
-            "text",
-          ],
-          Lutaml::Model::XmlAdapter::OxAdapter => [
-            "ApplicationSchema",
-            "ApplicationSchema",
-            "ApplicationSchema",
-          ],
-          Lutaml::Model::XmlAdapter::OgaAdapter => [
-            "text",
-            "ApplicationSchema",
-            "text",
-            "ApplicationSchema",
-            "text",
-            "ApplicationSchema",
-            "text",
-          ],
+          Lutaml::Model::XmlAdapter::NokogiriAdapter => nokogiri_pattern,
+          Lutaml::Model::XmlAdapter::OxAdapter => oga_ox_pattern,
+          Lutaml::Model::XmlAdapter::OgaAdapter => oga_ox_pattern,
         }
       end
 
-      let(:parsed) { XmlMapping::SameNameDifferentNamespace.from_xml(input_xml) }
+      let(:parsed) do
+        XmlMapping::SameNameDifferentNamespace.from_xml(input_xml)
+      end
+
+      def create_pattern_mapping(array)
+        array.map do |type, text|
+          Lutaml::Model::XmlAdapter::Element.new(type, text)
+        end
+      end
 
       it "citygml_application_schema should be correct" do
         expect(parsed.citygml_application_schema).to eq("CityGML App")
@@ -550,7 +658,8 @@ RSpec.describe Lutaml::Model::XmlMapping do
 
       it "sets the namespace for individual elements" do
         expect(mapping.elements.size).to eq(3)
-        expect(mapping.elements[0].namespace).to eq("https://example.com/ceramic/1.2")
+        expect(mapping.elements[0].namespace)
+          .to eq("https://example.com/ceramic/1.2")
         expect(mapping.elements[0].prefix).to eq("cera")
         expect(mapping.elements[1].delegate).to eq(:glaze)
       end
@@ -572,7 +681,8 @@ RSpec.describe Lutaml::Model::XmlMapping do
 
       it "sets the namespace for individual attributes" do
         expect(mapping.attributes.size).to eq(1)
-        expect(mapping.attributes[0].namespace).to eq("https://example.com/ceramic/1.2")
+        expect(mapping.attributes[0].namespace)
+          .to eq("https://example.com/ceramic/1.2")
         expect(mapping.attributes[0].prefix).to eq("cera")
       end
     end
@@ -625,7 +735,7 @@ RSpec.describe Lutaml::Model::XmlMapping 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)
+            mapping.map_attribute("schemaLocation", to: :schema_location)
           end.to output(error_regex).to_stderr
         end
       end
@@ -643,13 +753,32 @@ RSpec.describe Lutaml::Model::XmlMapping do
           XML
         end
 
+        let(:generated_xml) do
+          XmlMapping::SchemaLocationOrdered.from_xml(xml).to_xml
+        end
+
         it "contain schemaLocation attributes" do
-          expect(XmlMapping::SchemaLocationOrdered.from_xml(xml).to_xml).to be_equivalent_to(xml)
+          expect(generated_xml).to be_equivalent_to(xml)
         end
       end
     end
 
     context "with multiple schemaLocations" do
+      let(:nested_schema_location) do
+        Lutaml::Model::SchemaLocation.new(
+          schema_location: "http://www.opengis.net/gml/3.7 http://schemas.opengis.net/gml/3.7.1/gml.xsd http://www.isotc211.org/2005/gmd http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd",
+          prefix: "xsi",
+          namespace: "http://another-instance",
+        )
+      end
+
+      let(:schema_location) do
+        Lutaml::Model::SchemaLocation.new(
+          schema_location: "http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd http://www.w3.org/1999/xlink http://www.w3.org/1999/xlink.xsd",
+          prefix: "xsi",
+        )
+      end
+
       let(:xml) do
         <<~XML
           <p xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -662,60 +791,39 @@ RSpec.describe Lutaml::Model::XmlMapping do
         XML
       end
 
-      it "parses and serializes multiple schemaLocation attributes" do
-        parsed = Paragraph.from_xml(xml)
-        expect(parsed.schema_location.size).to eq(2)
-        expect(parsed.schema_location[0].namespace).to eq("http://www.opengis.net/gml/3.2")
-        expect(parsed.schema_location[0].location).to eq("http://schemas.opengis.net/gml/3.2.1/gml.xsd")
-        expect(parsed.schema_location[1].namespace).to eq("http://www.w3.org/1999/xlink")
-        expect(parsed.schema_location[1].location).to eq("http://www.w3.org/1999/xlink.xsd")
+      context "when deserializing" do
+        let(:parsed) { Paragraph.from_xml(xml) }
 
-        serialized = parsed.to_xml
-        expect(serialized).to be_equivalent_to(xml)
-        expect(serialized).to include('xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"')
-        expect(serialized).to include('xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd http://www.w3.org/1999/xlink http://www.w3.org/1999/xlink.xsd"')
-      end
+        it "parses correctly" do
+          expect(parsed.schema_location.size).to eq(2)
+          expect(parsed.schema_location[0]).to eq(schema_location[0])
+          expect(parsed.schema_location[1]).to eq(schema_location[1])
+        end
 
-      it "handles nested elements with different schemaLocations" do
-        parsed = Paragraph.from_xml(xml)
-        nested_p = parsed.paragraph
+        it "parses nested correctly" do
+          nested_p = parsed.paragraph
 
-        expect(nested_p).to be_a(Paragraph)
-        expect(nested_p.schema_location.size).to eq(2)
-        expect(nested_p.schema_location[0].namespace).to eq("http://www.opengis.net/gml/3.7")
-        expect(nested_p.schema_location[0].location).to eq("http://schemas.opengis.net/gml/3.7.1/gml.xsd")
-        expect(nested_p.schema_location[1].namespace).to eq("http://www.isotc211.org/2005/gmd")
-        expect(nested_p.schema_location[1].location).to eq("http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd")
+          expect(nested_p.schema_location.size).to eq(2)
+          expect(nested_p.schema_location[0]).to eq(nested_schema_location[0])
+          expect(nested_p.schema_location[1]).to eq(nested_schema_location[1])
+        end
+      end
 
-        serialized = parsed.to_xml
-        expect(serialized).to include('xmlns:xsi="http://another-instance"')
-        expect(serialized).to include('xsi:schemaLocation="http://www.opengis.net/gml/3.7 http://schemas.opengis.net/gml/3.7.1/gml.xsd http://www.isotc211.org/2005/gmd http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd"')
-      end
-
-      it "creates XML with multiple schemaLocations" do
-        paragraph = Paragraph.new(
-          schema_location: Lutaml::Model::SchemaLocation.new(
-            schema_location: {
-              "http://www.opengis.net/gml/3.2" => "http://schemas.opengis.net/gml/3.2.1/gml.xsd",
-              "http://www.w3.org/1999/xlink" => "http://www.w3.org/1999/xlink.xsd",
-            },
-            prefix: "xsi",
-          ),
-          paragraph: Paragraph.new(
-            schema_location: Lutaml::Model::SchemaLocation.new(
-              schema_location: {
-                "http://www.opengis.net/gml/3.7" => "http://schemas.opengis.net/gml/3.7.1/gml.xsd",
-                "http://www.isotc211.org/2005/gmd" => "http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd",
-              },
-              prefix: "xsi",
-              namespace: "http://another-instance",
+      context "when serializing" do
+        let(:paragraph) do
+          Paragraph.new(
+            schema_location: schema_location,
+            paragraph: Paragraph.new(
+              schema_location: nested_schema_location,
+              text: ["Some text inside paragraph"],
             ),
-            text: ["Some text inside paragraph"],
-          ),
-        )
+          )
+        end
 
-        serialized = paragraph.to_xml
-        expect(serialized).to be_equivalent_to(xml)
+        it "creates XML with multiple schemaLocations" do
+          serialized = paragraph.to_xml
+          expect(serialized).to be_equivalent_to(xml)
+        end
       end
     end
 
@@ -736,10 +844,10 @@ RSpec.describe Lutaml::Model::XmlMapping do
       end
 
       let(:expected_street) do
-        if Lutaml::Model::Config.xml_adapter == Lutaml::Model::XmlAdapter::OxAdapter
-          "<a>N</a>\n<p>adf</p>\n"
-        else
+        if Lutaml::Model::Config.xml_adapter == Lutaml::Model::XmlAdapter::NokogiriAdapter
           "\n      <a>N</a>\n      <p>adf</p>\n    "
+        else
+          "<a>N</a><p>adf</p>"
         end
       end
 
@@ -789,6 +897,16 @@ RSpec.describe Lutaml::Model::XmlMapping do
         orig_mappings.deep_dup
       end
 
+      XmlMapping::WithMapAll.mappings_for(:xml).instance_variables.each do |var|
+        it "duplicates #{var} correctly" do
+          orig_mapping = XmlMapping::WithMapAll.mappings_for(:xml)
+          dup_mappings = orig_mapping.deep_dup
+
+          expect(orig_mapping.instance_variable_get(var))
+            .to eq(dup_mappings.instance_variable_get(var))
+        end
+      end
+
       it "duplicates root_element" do
         orig_root = orig_mappings.root_element
         dup_root = dup_mappings.root_element
@@ -802,7 +920,8 @@ RSpec.describe Lutaml::Model::XmlMapping do
         dup_namespace_uri = dup_mappings.namespace_uri
 
         expect(orig_namespace_uri).to eq(dup_namespace_uri)
-        expect(orig_namespace_uri.object_id).not_to eq(dup_namespace_uri.object_id)
+        expect(orig_namespace_uri.object_id)
+          .not_to eq(dup_namespace_uri.object_id)
       end
 
       it "duplicates namespace_prefix" do
@@ -810,7 +929,8 @@ RSpec.describe Lutaml::Model::XmlMapping do
         dup_namespace_prefix = dup_mappings.namespace_prefix
 
         expect(orig_namespace_prefix).to eq(dup_namespace_prefix)
-        expect(orig_namespace_prefix.object_id).not_to eq(dup_namespace_prefix.object_id)
+        expect(orig_namespace_prefix.object_id)
+          .not_to eq(dup_namespace_prefix.object_id)
       end
 
       context "when duplicating mapping" do
@@ -822,7 +942,8 @@ RSpec.describe Lutaml::Model::XmlMapping do
           dup_custom_methods = dup_mapping.custom_methods
 
           expect(orig_custom_methods).to eq(dup_custom_methods)
-          expect(orig_custom_methods.object_id).not_to eq(dup_custom_methods.object_id)
+          expect(orig_custom_methods.object_id)
+            .not_to eq(dup_custom_methods.object_id)
         end
 
         it "duplicates default_namespace" do
@@ -830,7 +951,8 @@ RSpec.describe Lutaml::Model::XmlMapping do
           dup_default_namespace = dup_mapping.default_namespace
 
           expect(orig_default_namespace).to eq(dup_default_namespace)
-          expect(orig_default_namespace.object_id).not_to eq(dup_default_namespace.object_id)
+          expect(orig_default_namespace.object_id)
+            .not_to eq(dup_default_namespace.object_id)
         end
 
         it "duplicates delegate" do
@@ -886,6 +1008,11 @@ RSpec.describe Lutaml::Model::XmlMapping do
           # `to` is symbol which are constant so object_id will be same
           expect(orig_mapping.to).to eq(dup_mapping.to)
         end
+
+        it "duplicates attribute" do
+          # boolean value is constant so object_id will be same
+          expect(orig_mappings.attributes.first.attribute?).to eq(dup_mappings.attributes.first.attribute?)
+        end
       end
     end
 
@@ -957,7 +1084,11 @@ RSpec.describe Lutaml::Model::XmlMapping do
       end
 
       it "maps all the content including tags" do
-        inner_xml = "Str<sub>2</sub>text<sup>1</sup>123"
+        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>"
 
         parsed = XmlMapping::WithMapAll.from_xml(xml)
@@ -978,12 +1109,6 @@ RSpec.describe Lutaml::Model::XmlMapping do
           DESCRIPTION
         end
 
-        let(:expected_description) do
-          <<~DESCRIPTION
-            I'm a <b>web developer</b> with <strong>years</strong> of <i>experience</i> in many programing languages.
-          DESCRIPTION
-        end
-
         let(:xml) do
           <<~XML
             <WithNestedMapAll age="23">
@@ -995,17 +1120,6 @@ RSpec.describe Lutaml::Model::XmlMapping do
           XML
         end
 
-        let(:expected_xml) do
-          <<~XML
-            <WithNestedMapAll age="23">
-              <name>John Doe</name>
-              <description>
-                #{expected_description}
-              </description>
-            </WithNestedMapAll>
-          XML
-        end
-
         let(:parsed) do
           XmlMapping::WithNestedMapAll.from_xml(xml)
         end
@@ -1023,7 +1137,7 @@ RSpec.describe Lutaml::Model::XmlMapping do
         end
 
         it "round-trips xml" do
-          expect(parsed.to_xml).to be_equivalent_to(expected_xml)
+          expect(parsed.to_xml).to be_equivalent_to(xml)
         end
       end
 
@@ -1050,6 +1164,16 @@ RSpec.describe Lutaml::Model::XmlMapping do
           XML
         end
 
+        let(:expected_oga_xml) do
+          <<~XML.strip
+            <SpecialCharContentWithMapAll>
+              B <p>R&amp;C</p>
+              C <p>J—C</p>
+              O <p>A &amp; B </p>
+              F <p>Z © </p></SpecialCharContentWithMapAll>
+          XML
+        end
+
         let(:expected_ox_xml) do
           "<SpecialCharContentWithMapAll> " \
             "B <p>R&amp;C</p> " \
@@ -1059,9 +1183,19 @@ RSpec.describe Lutaml::Model::XmlMapping do
             "</SpecialCharContentWithMapAll>\n"
         end
 
+        let(:expected_xml) do
+          if adapter_class.type == "ox"
+            expected_ox_xml
+          elsif adapter_class.type == "oga"
+            expected_oga_xml
+          else
+            expected_nokogiri_xml
+          end
+        end
+
         it "round-trips xml" do
-          expected_xml = adapter_class.type == "ox" ? expected_ox_xml : expected_nokogiri_xml
-          expect(XmlMapping::SpecialCharContentWithMapAll.from_xml(xml).to_xml).to eq(expected_xml)
+          parsed = XmlMapping::SpecialCharContentWithMapAll.from_xml(xml)
+          expect(parsed.to_xml).to eq(expected_xml)
         end
       end
 
@@ -1074,8 +1208,12 @@ RSpec.describe Lutaml::Model::XmlMapping do
           XML
         end
 
+        let(:generated_xml) do
+          XmlMapping::Schema.from_xml(xml).to_xml
+        end
+
         it "round-trips xml" do
-          expect(XmlMapping::Schema.from_xml(xml).to_xml).to be_equivalent_to(xml)
+          expect(generated_xml).to be_equivalent_to(xml)
         end
       end
     end