lutaml-model 0.8.14 → 0.8.16

data/spec/lutaml/model/raw_element_spec.rb

@@ -0,0 +1,533 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module RawElementSpec
+  class SvgContainer < Lutaml::Model::Serializable
+    attribute :svg_data, :string
+
+    xml do
+      element "container"
+      map_element "svg", to: :svg_data, raw: :element
+    end
+  end
+
+  class MathContainer < Lutaml::Model::Serializable
+    attribute :formula, :string
+
+    xml do
+      element "container"
+      map_element "math", to: :formula, raw: :element
+    end
+  end
+
+  class MixedContainer < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :embedded, :string
+
+    xml do
+      element "container"
+      map_element "name", to: :name
+      map_element "foreign", to: :embedded, raw: :element
+    end
+  end
+
+  class NestedRawContainer < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :embedded, :string
+
+    xml do
+      element "container"
+      map_element "name", to: :name
+      map_element "embedded", to: :embedded, raw: :element
+    end
+  end
+
+  class MultiRawContainer < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :svg_data, :string
+    attribute :math_data, :string
+
+    xml do
+      element "container"
+      map_element "name", to: :name
+      map_element "svg", to: :svg_data, raw: :element
+      map_element "math", to: :math_data, raw: :element
+    end
+  end
+
+  class CollectionRawContainer < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :fragments, :string, collection: true
+
+    xml do
+      element "container"
+      map_element "name", to: :name
+      map_element "fragment", to: :fragments, raw: :element
+    end
+  end
+
+  class EmptyRawContainer < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :embedded, :string
+
+    xml do
+      element "container"
+      map_element "name", to: :name
+      map_element "foreign", to: :embedded, raw: :element
+    end
+  end
+
+  class NormalContainer < Lutaml::Model::Serializable
+    attribute :data, :string
+
+    xml do
+      element "container"
+      map_element "data", to: :data
+    end
+  end
+
+  RSpec.describe "map_element raw: :element" do
+    describe "deserialization" do
+      describe "foreign namespace element capture" do
+        let(:svg_xml) do
+          <<~XML
+            <container>
+              <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+                <rect x="0" y="0" width="100" height="100" fill="red"/>
+              </svg>
+            </container>
+          XML
+        end
+
+        it "captures the full SVG element including its own tags" do
+          doc = SvgContainer.from_xml(svg_xml)
+          expect(doc.svg_data).to include("<svg")
+          expect(doc.svg_data).to include("</svg>")
+          expect(doc.svg_data).to include("viewBox")
+          expect(doc.svg_data).to include("<rect")
+        end
+
+        it "preserves SVG namespace attribute" do
+          doc = SvgContainer.from_xml(svg_xml)
+          expect(doc.svg_data).to include("xmlns=\"http://www.w3.org/2000/svg\"")
+        end
+
+        it "preserves child elements" do
+          doc = SvgContainer.from_xml(svg_xml)
+          expect(doc.svg_data).to include("<rect")
+          expect(doc.svg_data).to include("fill=\"red\"")
+        end
+      end
+
+      describe "non-namespaced element capture" do
+        let(:math_xml) do
+          "<container><math><mfrac><mi>x</mi><mn>2</mn></mfrac></math></container>"
+        end
+
+        it "captures the full element" do
+          doc = MathContainer.from_xml(math_xml)
+          expect(doc.formula).to include("<math>")
+          expect(doc.formula).to include("</math>")
+          expect(doc.formula).to include("<mfrac>")
+        end
+      end
+
+      describe "mixed mapped and raw elements" do
+        let(:mixed_xml) do
+          <<~XML
+            <container>
+              <name>test</name>
+              <foreign attr="value">
+                <child>content</child>
+              </foreign>
+            </container>
+          XML
+        end
+
+        it "parses normal elements normally" do
+          doc = MixedContainer.from_xml(mixed_xml)
+          expect(doc.name).to eq("test")
+        end
+
+        it "captures raw elements as full XML" do
+          doc = MixedContainer.from_xml(mixed_xml)
+          expect(doc.embedded).to include("<foreign")
+          expect(doc.embedded).to include("</foreign>")
+          expect(doc.embedded).to include("attr=\"value\"")
+          expect(doc.embedded).to include("<child>content</child>")
+        end
+      end
+
+      describe "nested XML in raw element" do
+        let(:nested_xml) do
+          <<~XML
+            <container>
+              <name>test</name>
+              <embedded>
+                <level1>
+                  <level2 attr="deep">text</level2>
+                </level1>
+              </embedded>
+            </container>
+          XML
+        end
+
+        it "preserves full nesting" do
+          doc = NestedRawContainer.from_xml(nested_xml)
+          expect(doc.embedded).to include("<level1>")
+          expect(doc.embedded).to include("<level2 attr=\"deep\">text</level2>")
+          expect(doc.embedded).to include("</level1>")
+        end
+      end
+
+      describe "multiple raw: :element mappings" do
+        let(:multi_xml) do
+          <<~XML
+            <container>
+              <name>mixed content</name>
+              <svg xmlns="http://www.w3.org/2000/svg"><circle r="5"/></svg>
+              <math><mi>&#x3C0;</mi></math>
+            </container>
+          XML
+        end
+
+        it "captures each raw element independently" do
+          doc = MultiRawContainer.from_xml(multi_xml)
+          expect(doc.name).to eq("mixed content")
+          expect(doc.svg_data).to include("<svg")
+          expect(doc.svg_data).to include("<circle")
+          expect(doc.math_data).to include("<math>")
+          expect(doc.math_data).to include("<mi>")
+        end
+      end
+
+      describe "collection raw: :element" do
+        let(:collection_xml) do
+          <<~XML
+            <container>
+              <name>multi</name>
+              <fragment id="1">first</fragment>
+              <fragment id="2">second</fragment>
+              <fragment id="3"><nested>third</nested></fragment>
+            </container>
+          XML
+        end
+
+        it "captures each occurrence as a collection item" do
+          doc = CollectionRawContainer.from_xml(collection_xml)
+          expect(doc.name).to eq("multi")
+          expect(doc.fragments.length).to eq(3)
+          expect(doc.fragments[0]).to include("<fragment")
+          expect(doc.fragments[0]).to include("first")
+          expect(doc.fragments[1]).to include("second")
+          expect(doc.fragments[2]).to include("<nested>third</nested>")
+        end
+      end
+
+      describe "missing raw element" do
+        it "returns nil when raw element is absent" do
+          doc = SvgContainer.from_xml("<container><other>text</other></container>")
+          expect(doc.svg_data).to be_nil
+        end
+      end
+
+      describe "empty raw element" do
+        it "captures self-closing empty element" do
+          doc = EmptyRawContainer.from_xml("<container><name>test</name><foreign/></container>")
+          expect(doc.embedded).to include("<foreign")
+          expect(doc.embedded).to include("/")
+        end
+      end
+
+      describe "XML special characters" do
+        it "preserves entities in raw element content" do
+          xml = "<container><foreign>a &amp; b &lt; c</foreign></container>"
+          doc = MixedContainer.from_xml("<container><name>test</name>#{xml.match(/<container>(.*)<\/container>/m)[1]}</container>")
+          expect(doc.embedded).to include("<foreign")
+        end
+      end
+
+      describe "namespace matching" do
+        it "captures element with xmlns declaration on itself" do
+          doc = SvgContainer.from_xml(
+            '<container><svg xmlns="http://www.w3.org/2000/svg"><rect/></svg></container>',
+          )
+          expect(doc.svg_data).to include("<svg")
+          expect(doc.svg_data).to include('xmlns="http://www.w3.org/2000/svg"')
+        end
+
+        it "captures element with no namespace" do
+          doc = SvgContainer.from_xml(
+            "<container><svg><rect/></svg></container>",
+          )
+          expect(doc.svg_data).to include("<svg")
+          expect(doc.svg_data).to include("<rect")
+        end
+
+        it "captures explicitly prefixed element" do
+          doc = SvgContainer.from_xml(
+            '<container xmlns:s="http://www.w3.org/2000/svg"><s:svg><s:rect/></s:svg></container>',
+          )
+          expect(doc.svg_data).to include("<s:svg")
+          expect(doc.svg_data).to include("<s:rect")
+        end
+      end
+    end
+
+    describe "serialization" do
+      describe "round-trip with SVG" do
+        let(:svg_xml) do
+          <<~XML
+            <container>
+              <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+                <rect x="0" y="0" width="100" height="100" fill="red"/>
+              </svg>
+            </container>
+          XML
+        end
+
+        it "preserves SVG data through parse -> serialize -> parse" do
+          doc = SvgContainer.from_xml(svg_xml)
+          output = doc.to_xml
+          doc2 = SvgContainer.from_xml(output)
+          expect(doc2.svg_data).to include("<svg")
+          expect(doc2.svg_data).to include("</svg>")
+          expect(doc2.svg_data).to include("viewBox")
+          expect(doc2.svg_data).to include("<rect")
+          expect(doc2.svg_data).to include("xmlns=\"http://www.w3.org/2000/svg\"")
+        end
+      end
+
+      describe "round-trip with mixed content" do
+        let(:mixed_xml) do
+          '<container><name>test</name><foreign attr="value"><child>content</child></foreign></container>'
+        end
+
+        it "preserves both normal and raw elements" do
+          doc = MixedContainer.from_xml(mixed_xml)
+          output = doc.to_xml
+          doc2 = MixedContainer.from_xml(output)
+          expect(doc2.name).to eq("test")
+          expect(doc2.embedded).to include("<foreign")
+          expect(doc2.embedded).to include("attr=\"value\"")
+          expect(doc2.embedded).to include("<child>content</child>")
+        end
+      end
+
+      describe "round-trip with nested raw XML" do
+        let(:nested_xml) do
+          '<container><name>test</name><embedded><level1><level2 attr="deep">text</level2></level1></embedded></container>'
+        end
+
+        it "preserves full nesting depth" do
+          doc = NestedRawContainer.from_xml(nested_xml)
+          output = doc.to_xml
+          doc2 = NestedRawContainer.from_xml(output)
+          expect(doc2.embedded).to include("<level1>")
+          expect(doc2.embedded).to include("<level2 attr=\"deep\">text</level2>")
+          expect(doc2.embedded).to include("</level1>")
+        end
+      end
+
+      describe "building from model instance" do
+        it "serializes a programmatically created model" do
+          model = SvgContainer.new(svg_data: '<svg xmlns="http://www.w3.org/2000/svg"><circle r="5"/></svg>')
+          xml = model.to_xml
+          expect(xml).to include("<svg")
+          expect(xml).to include("<circle")
+          expect(xml).to include("</svg>")
+        end
+
+        it "round-trips a programmatically created model" do
+          original_svg = '<svg xmlns="http://www.w3.org/2000/svg"><circle r="5"/></svg>'
+          model = SvgContainer.new(svg_data: original_svg)
+          xml = model.to_xml
+          doc = SvgContainer.from_xml(xml)
+          expect(doc.svg_data).to include("<svg")
+          expect(doc.svg_data).to include("<circle")
+          expect(doc.svg_data).to include("</svg>")
+        end
+
+        it "does not double-escape raw element content" do
+          model = SvgContainer.new(svg_data: "<svg><rect/></svg>")
+          xml = model.to_xml
+          expect(xml).not_to include("&lt;svg")
+          expect(xml).not_to include("&gt;")
+        end
+      end
+
+      describe "round-trip with collection" do
+        let(:collection_xml) do
+          <<~XML
+            <container>
+              <name>multi</name>
+              <fragment id="1">first</fragment>
+              <fragment id="2">second</fragment>
+            </container>
+          XML
+        end
+
+        it "preserves all collection items" do
+          doc = CollectionRawContainer.from_xml(collection_xml)
+          output = doc.to_xml
+          doc2 = CollectionRawContainer.from_xml(output)
+          expect(doc2.fragments.length).to eq(2)
+          expect(doc2.fragments[0]).to include("first")
+          expect(doc2.fragments[1]).to include("second")
+        end
+      end
+
+      describe "nil and empty values" do
+        it "omits raw element when value is nil" do
+          model = SvgContainer.new(svg_data: nil)
+          xml = model.to_xml
+          expect(xml).not_to include("<svg")
+        end
+
+        it "omits raw element when value is empty string" do
+          model = SvgContainer.new(svg_data: "")
+          xml = model.to_xml
+          expect(xml).not_to include("<svg")
+        end
+      end
+
+      describe "XML special characters round-trip" do
+        it "preserves angle brackets in raw element content without double-escaping" do
+          doc = MixedContainer.from_xml(
+            '<container><name>test</name><foreign><child a="1">x &amp; y</child></foreign></container>',
+          )
+          output = doc.to_xml
+          expect(output).to include("<child")
+          expect(output).not_to include("&lt;child")
+          doc2 = MixedContainer.from_xml(output)
+          expect(doc2.embedded).to include("<child")
+          expect(doc2.embedded).to include("x &amp; y")
+        end
+      end
+    end
+
+    describe "default behavior (no raw)" do
+      it "does not capture raw XML for normal map_element" do
+        doc = NormalContainer.from_xml("<container><data>text</data></container>")
+        expect(doc.data).to eq("text")
+        expect(doc.data).not_to include("<data>")
+      end
+
+      it "serializes text content normally" do
+        model = NormalContainer.new(data: "hello")
+        xml = model.to_xml
+        expect(xml).to include("<data>hello</data>")
+        expect(xml).not_to include("&lt;")
+      end
+    end
+
+    describe "MappingRule attributes" do
+      it "defaults raw to nil" do
+        rule = MixedContainer.mappings_for(:xml).elements.find do |r|
+          r.to == :name
+        end
+        expect(rule.raw).to be_nil
+      end
+
+      it "sets raw to :element when specified" do
+        rule = MixedContainer.mappings_for(:xml).elements.find do |r|
+          r.to == :embedded
+        end
+        expect(rule.raw).to eq(:element)
+      end
+
+      it "provides raw_element backward-compat alias" do
+        rule = MixedContainer.mappings_for(:xml).elements.find do |r|
+          r.to == :embedded
+        end
+        expect(rule.raw_element?).to be(true)
+      end
+
+      it "propagates raw through deep_dup" do
+        rule = MixedContainer.mappings_for(:xml).elements.find do |r|
+          r.to == :embedded
+        end
+        dup = rule.deep_dup
+        expect(dup.raw).to eq(:element)
+      end
+    end
+
+    describe "raw parameter validation" do
+      it "accepts :element" do
+        expect do
+          Lutaml::Xml::MappingRule.new("test", to: :x, raw: :element)
+        end.not_to raise_error
+      end
+
+      it "accepts :content" do
+        expect do
+          Lutaml::Xml::MappingRule.new("test", to: :x, raw: :content)
+        end.not_to raise_error
+      end
+
+      it "accepts nil" do
+        rule = Lutaml::Xml::MappingRule.new("test", to: :x, raw: nil)
+        expect(rule.raw).to be_nil
+      end
+
+      it "rejects invalid values" do
+        expect do
+          Lutaml::Xml::MappingRule.new("test", to: :x, raw: :invalid)
+        end.to raise_error(ArgumentError, /raw must be :element or :content/)
+      end
+
+      it "deprecates raw: true with warning" do
+        expect do
+          Lutaml::Xml::MappingRule.new("test", to: :x, raw: true)
+        end.to output(/DEPRECATED.*raw: :element/).to_stderr
+      end
+
+      it "treats raw: true as :element" do
+        rule = nil
+        expect do
+          rule = Lutaml::Xml::MappingRule.new("test", to: :x, raw: true)
+        end.to output(/DEPRECATED/).to_stderr
+        expect(rule.raw).to eq(:element)
+      end
+    end
+  end
+
+  # raw: :content mode — inner XML capture
+  module RawContentSpec
+    class StreetContainer < Lutaml::Model::Serializable
+      attribute :street, :string
+
+      xml do
+        element "address"
+        map_element "street", to: :street, raw: :content
+      end
+    end
+
+    RSpec.describe "map_element raw: :content" do
+      describe "deserialization" do
+        it "captures inner XML content" do
+          doc = StreetContainer.from_xml("<address><street><b>123</b> Main St</street></address>")
+          expect(doc.street).to include("<b>123</b>")
+          expect(doc.street).to include("Main St")
+        end
+
+        it "does not include wrapper tags" do
+          doc = StreetContainer.from_xml("<address><street><b>123</b> Main St</street></address>")
+          expect(doc.street).not_to include("<street>")
+          expect(doc.street).not_to include("</street>")
+        end
+      end
+
+      describe "serialization" do
+        it "round-trips inner XML content" do
+          doc = StreetContainer.from_xml("<address><street><b>123</b> Main St</street></address>")
+          output = doc.to_xml
+          doc2 = StreetContainer.from_xml(output)
+          expect(doc2.street).to include("<b>123</b>")
+          expect(doc2.street).to include("Main St")
+        end
+      end
+    end
+  end
+end

data/spec/lutaml/rdf/mapping_spec.rb

@@ -46,6 +46,54 @@ RSpec.describe Lutaml::Rdf::Mapping do
     end
   end
 
+  describe "#types" do
+    it "stores multiple types from splat arguments" do
+      mapping.types("skos:Concept", "dcterms:Agent")
+      expect(mapping.rdf_type).to eq(["skos:Concept", "dcterms:Agent"])
+    end
+
+    it "stores single type" do
+      mapping.types("skos:Concept")
+      expect(mapping.rdf_type).to eq(["skos:Concept"])
+    end
+
+    it "flattens nested arrays" do
+      mapping.types(["skos:Concept", "owl:Thing"], "foaf:Person")
+      expect(mapping.rdf_type).to eq(["skos:Concept", "owl:Thing",
+                                      "foaf:Person"])
+    end
+
+    it "overwrites previous types on subsequent call" do
+      mapping.types("skos:Concept")
+      mapping.types("dcterms:Agent")
+      expect(mapping.rdf_type).to eq(["dcterms:Agent"])
+    end
+  end
+
+  describe "#has_types_or_predicates?" do
+    it "returns false when no types or predicates" do
+      expect(mapping.has_types_or_predicates?).to be(false)
+    end
+
+    it "returns true when types are present" do
+      mapping.type("skos:Concept")
+      expect(mapping.has_types_or_predicates?).to be(true)
+    end
+
+    it "returns true when predicates are present" do
+      mapping.predicate(:prefLabel,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
+      expect(mapping.has_types_or_predicates?).to be(true)
+    end
+
+    it "returns true when both types and predicates present" do
+      mapping.type("skos:Concept")
+      mapping.predicate(:prefLabel,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
+      expect(mapping.has_types_or_predicates?).to be(true)
+    end
+  end
+
   describe "#predicate" do
     it "creates MappingRule with namespace reference" do
       mapping.predicate(
@@ -128,13 +176,13 @@ RSpec.describe Lutaml::Rdf::Mapping do
   end
 
   describe "#members" do
-    it "creates MemberRule" do
+    it "creates MemberRule without linking predicate" do
       mapping.members(:items)
       expect(mapping.rdf_members.length).to eq(1)
       expect(mapping.rdf_members.first.attr_name).to eq(:items)
     end
 
-    it "creates MemberRule with linking predicate" do
+    it "creates MemberRule with static linking predicate" do
       mapping.members(:items,
                       predicate_name: :member,
                       namespace: Lutaml::Rdf::Namespaces::SkosNamespace)
@@ -143,11 +191,19 @@ RSpec.describe Lutaml::Rdf::Mapping do
       expect(rule.linked_predicate_uri).to eq("http://www.w3.org/2004/02/skos/core#member")
     end
 
-    it "creates MemberRule without linking predicate" do
-      mapping.members(:items)
+    it "creates MemberRule with link as String" do
+      mapping.members(:items, link: "skos:member")
       rule = mapping.rdf_members.first
-      expect(rule.linked?).to be(false)
-      expect(rule.linked_predicate_uri).to be_nil
+      expect(rule.linked?).to be(true)
+      expect(rule.link).to eq("skos:member")
+    end
+
+    it "creates MemberRule with link as Proc" do
+      resolver = ->(item) { "skos:#{item.type}" }
+      mapping.members(:items, link: resolver)
+      rule = mapping.rdf_members.first
+      expect(rule.linked?).to be(true)
+      expect(rule.link).to eq(resolver)
     end
 
     it "raises when predicate_name given without namespace" do
@@ -155,6 +211,15 @@ RSpec.describe Lutaml::Rdf::Mapping do
         mapping.members(:items, predicate_name: :member)
       end.to raise_error(ArgumentError, /namespace is required/)
     end
+
+    it "raises when predicate_name and link both given" do
+      expect do
+        mapping.members(:items,
+                        predicate_name: :member,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                        link: "skos:member")
+      end.to raise_error(ArgumentError, /mutually exclusive/)
+    end
   end
 
   describe "#mappings" do