lutaml-model 0.8.15 → 0.8.17

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/model/uninitialized_class_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe Lutaml::Model::UninitializedClass do
 
   describe "#match?" do
     it "returns false for any argument" do
-      expect(uninitialized).not_to match /pattern/
+      expect(uninitialized).not_to include("pattern")
       expect(uninitialized).not_to match "string"
       expect(uninitialized).not_to match nil
     end

data/spec/lutaml/model/xsd_form_default_patterns_spec.rb

@@ -85,7 +85,7 @@ RSpec.describe "XSD Form Default Patterns" do
         xml = instance.to_xml
 
         # The element should be unqualified (no prefix) in instance
-        expect(xml).to match(%r{<premium})
+        expect(xml).to include("<premium")
         expect(xml).to include("<elementFormUnqualified")
       end
     end
@@ -281,7 +281,7 @@ RSpec.describe "XSD Form Default Patterns" do
         # and the namespace is already declared on an ancestor
         # The child element should be in the blank namespace without xmlns="" declaration
         # because the parent uses prefix format (xmlns:ex) or the namespace is already declared.
-        expect(result).not_to match(%r{xmlns=""})
+        expect(result).not_to include('xmlns=""')
       end
 
       it "serializes root element with namespace declaration" do

data/spec/lutaml/model/xsd_patterns_spec.rb

@@ -43,7 +43,7 @@ RSpec.describe "XSD Three Pattern Architecture" do
 
       expect(xsd).to include('<element name="item">')
       expect(xsd).to include("<complexType>")
-      expect(xsd).not_to match(/<complexType name=/)
+      expect(xsd).not_to include("<complexType name=")
       expect(xsd).to include('<attribute name="id" type="xs:string"/>')
     end
   end
@@ -68,7 +68,7 @@ RSpec.describe "XSD Three Pattern Architecture" do
       expect(xsd).to include('<element name="name" type="xs:string"/>')
       expect(xsd).to include('<element name="value" type="xs:integer"/>')
       # Should NOT generate standalone element declaration
-      expect(xsd).not_to match(/<element name="product"/)
+      expect(xsd).not_to include('<element name="product"')
     end
 
     it "type-only model can be referenced by other elements" do
@@ -233,7 +233,7 @@ RSpec.describe "XSD Three Pattern Architecture" do
 
       xsd = Lutaml::Model::Schema.to_xsd(klass)
       expect(xsd).to include('<element name="simple">')
-      expect(xsd).not_to match(/<element name="simple" type=/)
+      expect(xsd).not_to include('<element name="simple" type=')
     end
 
     it "Pattern 2: type_name only -> named reusable" do
@@ -252,7 +252,7 @@ RSpec.describe "XSD Three Pattern Architecture" do
       xsd = Lutaml::Model::Schema.to_xsd(klass)
       expect(xsd).to include('<complexType name="SimpleType">')
       # Should not have standalone element declaration (only child elements in sequence are OK)
-      expect(xsd).not_to match(/<element name="SimpleType"/)
+      expect(xsd).not_to include('<element name="SimpleType"')
     end
 
     it "Pattern 3: both -> element with named type" do

data/spec/lutaml/{jsonld → rdf}/context_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "lutaml/jsonld"
+require "lutaml/rdf"
 
-RSpec.describe Lutaml::JsonLd::Context do
+RSpec.describe Lutaml::Rdf::Context do
   subject(:ctx) { described_class.new }
 
   describe "empty context" do

data/spec/lutaml/{jsonld/transform_spec.rb → rdf/linked_data_transform_spec.rb}

@@ -2,8 +2,9 @@
 
 require "spec_helper"
 require "lutaml/jsonld"
+require "lutaml/yamlld"
 
-RSpec.describe Lutaml::JsonLd::Transform do
+RSpec.describe Lutaml::Rdf::LinkedDataTransform do
   before do
     stub_const("TestSkosNs", Class.new(Lutaml::Rdf::Namespace) do
       uri "http://www.w3.org/2004/02/skos/core#"
@@ -138,6 +139,19 @@ RSpec.describe Lutaml::JsonLd::Transform do
       expect(parsed["@context"]["skos"]).to eq("http://www.w3.org/2004/02/skos/core#")
       expect(parsed["@context"]["ex"]).to eq("http://example.org/")
     end
+
+    it "preserves data through model → YAML-LD → model" do
+      yaml = instance.to_yamlld
+      restored = JsonLdTestModel.from_yamlld(yaml)
+      expect(restored.name).to eq("test")
+      expect(restored.description).to eq("A test concept")
+    end
+
+    it "produces the same data model from YAML-LD as JSON-LD" do
+      from_yamlld = YAML.safe_load(instance.to_yamlld)
+      from_jsonld = JSON.parse(instance.to_jsonld)
+      expect(from_yamlld).to eq(from_jsonld)
+    end
   end
 
   describe "nil attribute values" do
@@ -492,7 +506,9 @@ RSpec.describe Lutaml::JsonLd::Transform do
         ],
       )
       parsed = JSON.parse(parent.to_jsonld)
-      parent_resource = parsed["@graph"].find { |r| r["@type"] == "skos:Collection" }
+      parent_resource = parsed["@graph"].find do |r|
+        r["@type"] == "skos:Collection"
+      end
       expect(parent_resource["member"]).to eq([
                                                 { "@id" => "http://example.org/item/a" },
                                                 { "@id" => "http://example.org/item/b" },

data/spec/lutaml/rdf/mapping_spec.rb

@@ -59,7 +59,8 @@ RSpec.describe Lutaml::Rdf::Mapping do
 
     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"])
+      expect(mapping.rdf_type).to eq(["skos:Concept", "owl:Thing",
+                                      "foaf:Person"])
     end
 
     it "overwrites previous types on subsequent call" do

data/spec/lutaml/{jsonld → rdf}/term_definition_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "lutaml/jsonld"
+require "lutaml/rdf"
 
-RSpec.describe Lutaml::JsonLd::TermDefinition do
+RSpec.describe Lutaml::Rdf::TermDefinition do
   it "simple term maps to name => id" do
     td = described_class.new(name: "name", id: "http://example.org/name")
     expect(td.to_context_hash).to eq("name" => "http://example.org/name")