lutaml-model 0.8.4 → 0.8.6

data/spec/lutaml/turtle/transform_spec.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+
+RSpec.describe Lutaml::Turtle::Transform do
+  before do
+    stub_const("TurtleTestModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :description, :string
+      attribute :code, :string
+
+      turtle do
+        namespace Lutaml::Rdf::Namespaces::SkosNamespace,
+                  Lutaml::Rdf::Namespaces::DctermsNamespace
+
+        subject { |m| "http://example.org/concept/#{m.code}" }
+
+        type "skos:Concept"
+
+        predicate :prefLabel,
+                  namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                  to: :name,
+                  lang_tagged: true
+
+        predicate :definition,
+                  namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                  to: :description
+
+        predicate :notation,
+                  namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                  to: :code
+      end
+    end)
+  end
+
+  let(:instance) do
+    TurtleTestModel.new(name: "test concept",
+                        description: "A test description",
+                        code: "2119")
+  end
+
+  describe "model_to_data" do
+    let(:result) { instance.to_turtle }
+
+    it "generates prefix declarations for used namespaces" do
+      expect(result).to include("@prefix skos: <http://www.w3.org/2004/02/skos/core#>")
+    end
+
+    it "generates subject URI" do
+      expect(result).to include("<http://example.org/concept/2119>")
+    end
+
+    it "generates rdf:type triple using compact prefix" do
+      expect(result).to include("a skos:Concept")
+    end
+
+    it "generates predicate triples" do
+      expect(result).to include("skos:notation \"2119\"")
+      expect(result).to include("skos:definition \"A test description\"")
+    end
+
+    it "terminates with a period" do
+      expect(result.strip).to end_with(".")
+    end
+  end
+
+  describe "special character escaping" do
+    let(:instance) do
+      TurtleTestModel.new(name: "has \"quotes\" and\nnewlines",
+                          description: "back\\slash",
+                          code: "1")
+    end
+
+    it "escapes double quotes in literals" do
+      result = instance.to_turtle
+      expect(result).to include('\\"quotes\\"')
+    end
+
+    it "handles multiline literals via triple-quoted strings" do
+      result = instance.to_turtle
+      expect(result).to include("has")
+      expect(result).to include("newlines")
+    end
+
+    it "escapes backslashes in literals" do
+      result = instance.to_turtle
+      expect(result).to include("back\\\\slash")
+    end
+  end
+
+  describe "numeric and boolean values" do
+    before do
+      stub_const("TypedModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+        attribute :count, :integer
+        attribute :active, :boolean
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |_| "http://example.org/1" }
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :label
+
+          predicate :notation,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :count
+
+          predicate :note,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :active
+        end
+      end)
+    end
+
+    it "serializes integers as native Turtle literals" do
+      instance = TypedModel.new(label: "test", count: 42, active: true)
+      result = instance.to_turtle
+      expect(result).to match(/skos:notation 42/)
+    end
+
+    it "serializes booleans as native Turtle literals" do
+      instance = TypedModel.new(label: "test", count: 1, active: true)
+      result = instance.to_turtle
+      expect(result).to match(/skos:note true/)
+    end
+  end
+
+  describe "model without subject" do
+    before do
+      stub_const("NoSubjectModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+          type "skos:Concept"
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    it "raises MissingSubjectError" do
+      instance = NoSubjectModel.new(name: "test")
+      expect { instance.to_turtle }
+        .to raise_error(Lutaml::Turtle::MissingSubjectError)
+    end
+  end
+
+  describe "model with nil values" do
+    let(:instance) { TurtleTestModel.new(name: "test", code: "2119") }
+
+    it "omits predicates for nil attributes" do
+      result = instance.to_turtle
+      expect(result).not_to include("definition")
+      expect(result).to include("prefLabel")
+    end
+  end
+
+  describe "model with no predicates producing data" do
+    before do
+      stub_const("EmptyPredModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/#{m.name}" }
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    let(:instance) { EmptyPredModel.new(name: nil) }
+
+    it "returns empty string when no data" do
+      expect(instance.to_turtle).to eq("")
+    end
+  end
+
+  describe "collection predicates" do
+    before do
+      stub_const("CollectionModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :labels, :string, collection: true
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |_| "http://example.org/1" }
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :labels
+        end
+      end)
+    end
+
+    it "generates triples for all collection values" do
+      instance = CollectionModel.new(labels: ["en", "fr"])
+      result = instance.to_turtle
+      expect(result).to include('"en"')
+      expect(result).to include('"fr"')
+      expect(result).to include("skos:prefLabel")
+    end
+  end
+
+  describe "full URI type (no prefix)" do
+    before do
+      stub_const("FullUriTypeModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/#{m.name}" }
+
+          type "http://example.org/MyType"
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    it "uses full URI as-is when no colon prefix" do
+      instance = FullUriTypeModel.new(name: "test")
+      result = instance.to_turtle
+      expect(result).to include("<http://example.org/MyType>")
+    end
+  end
+
+  describe "data_to_model (deserialization)" do
+    let(:turtle_input) do
+      <<~TURTLE
+        @prefix skos: <http://www.w3.org/2004/02/skos/core#> .
+        @prefix dcterms: <http://purl.org/dc/terms/> .
+
+        <http://example.org/concept/2119> a skos:Concept ;
+          skos:prefLabel "test concept"@en ;
+          skos:definition "A test description" ;
+          skos:notation "2119" .
+      TURTLE
+    end
+
+    it "deserializes string attributes" do
+      model = TurtleTestModel.from_turtle(turtle_input)
+      expect(model.code).to eq("2119")
+      expect(model.description).to eq("A test description")
+    end
+
+    it "deserializes language-tagged values" do
+      model = TurtleTestModel.from_turtle(turtle_input)
+      expect(model.name).to eq("test concept")
+    end
+  end
+
+  describe "round-trip" do
+    it "preserves data through model → Turtle → model" do
+      turtle = instance.to_turtle
+      restored = TurtleTestModel.from_turtle(turtle)
+      expect(restored.code).to eq("2119")
+      expect(restored.description).to eq("A test description")
+    end
+  end
+end

data/spec/lutaml/xml/adapter/base_adapter_regression_spec.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model"
+require "lutaml/xml"
+require "lutaml/xml/adapter/nokogiri_adapter"
+require "lutaml/xml/adapter/ox_adapter"
+require "lutaml/xml/adapter/oga_adapter"
+require "lutaml/xml/adapter/rexml_adapter"
+
+# Regression tests for BaseAdapter refactoring.
+# Each test guards a specific bug fix to prevent re-introduction.
+# Run against all 4 adapters to ensure consistent behavior.
+RSpec.shared_examples "base adapter regressions" do |adapter_class|
+  let(:adapter) { adapter_class }
+
+  describe "CDATA preservation in mixed content" do
+    let(:xml_with_cdata) do
+      "<root><![CDATA[Hello]]><b>world</b><![CDATA[!]]></root>"
+    end
+
+    it "preserves CDATA wrapping for mixed content string nodes" do
+      doc = adapter.parse(xml_with_cdata)
+      output = doc.to_xml
+
+      expect(output).to include("<![CDATA[Hello]]>")
+      expect(output).to include("<![CDATA[!]]>")
+    end
+  end
+
+  describe "XML comment preservation in serialization" do
+    let(:xml_with_comment) do
+      "<root><a/><!--middle comment--><b/></root>"
+    end
+
+    it "preserves comments during round-trip" do
+      doc = adapter.parse(xml_with_comment)
+      output = doc.to_xml
+
+      expect(output).to include("<!--middle comment-->")
+    end
+  end
+
+  describe "processing instructions do not affect text shape" do
+    let(:xml_with_pi_and_text) do
+      "<root>hello<?pi data?></root>"
+    end
+
+    let(:xml_with_only_pi) do
+      "<root><?pi data?></root>"
+    end
+
+    it "returns text as a string when PI is alongside text" do
+      doc = adapter.parse(xml_with_pi_and_text)
+
+      # text should be a string, not an array —
+      # PIs should not make plain text look like mixed content
+      expect(doc.text).to be_a(String)
+      expect(doc.text).to eq("hello")
+    end
+
+    it "returns empty string for text when element has only PI" do
+      doc = adapter.parse(xml_with_only_pi)
+
+      expect(doc.text).to be_a(String)
+      expect(doc.text).to eq("")
+    end
+  end
+
+  describe "processing instructions excluded from parse_element" do
+    let(:xml_with_pi) do
+      "<root><?foo ignored?><bar>content</bar></root>"
+    end
+
+    it "does not include PI in elements hash" do
+      doc = adapter.parse(xml_with_pi)
+      hash = doc.to_h
+
+      elements = hash["elements"]
+      expect(elements).to have_key("bar")
+      # PI should not appear as an element key
+      expect(elements.keys).not_to include("foo")
+    end
+  end
+
+  describe "ASCII-8BIT encoding round-trip" do
+    let(:binary_xml) { "<root>\xC2\xB5</root>".b }
+
+    it "round-trips binary-tagged UTF-8 content without encoding error" do
+      doc = adapter.parse(binary_xml)
+
+      expect { doc.to_xml }.not_to raise_error
+      expect(doc.to_xml).to include("\u00B5") # micro sign
+    end
+
+    it "does not use ASCII-8BIT as output encoding" do
+      doc = adapter.parse(binary_xml)
+      output = doc.to_xml
+
+      expect(output.encoding).not_to eq(Encoding::ASCII_8BIT)
+    end
+  end
+
+  describe "namespaced_attr_name helper arity" do
+    it "resolves single-arg namespaced_attr_name from AdapterHelpers" do
+      # This verifies the AdapterHelpers version (single Moxml attribute arg)
+      # is accessible and not shadowed by a 2-arg def self. method
+      expect(adapter).to respond_to(:namespaced_attr_name)
+
+      # The method should accept 1 argument (a Moxml attribute object)
+      method = adapter.method(:namespaced_attr_name)
+      expect(method.arity).to eq(1)
+    end
+  end
+
+  describe "XmlParser helper methods are private" do
+    it "does not expose normalize_xml_for_parse as a public class method" do
+      expect(adapter.public_methods).not_to include(:normalize_xml_for_parse)
+    end
+
+    it "does not expose parse_with_moxml as a public class method" do
+      expect(adapter.public_methods).not_to include(:parse_with_moxml)
+    end
+
+    it "does not expose raise_empty_document_error as a public class method" do
+      expect(adapter.public_methods).not_to include(:raise_empty_document_error)
+    end
+
+    it "exposes parse as a public class method" do
+      expect(adapter.public_methods).to include(:parse)
+    end
+  end
+end
+
+RSpec.describe Lutaml::Xml::Adapter::BaseAdapter do
+  context "with NokogiriAdapter" do
+    it_behaves_like "base adapter regressions", Lutaml::Xml::Adapter::NokogiriAdapter
+  end
+
+  context "with OxAdapter" do
+    it_behaves_like "base adapter regressions", Lutaml::Xml::Adapter::OxAdapter
+  end
+
+  context "with OgaAdapter" do
+    it_behaves_like "base adapter regressions", Lutaml::Xml::Adapter::OgaAdapter
+  end
+
+  context "with RexmlAdapter" do
+    it_behaves_like "base adapter regressions", Lutaml::Xml::Adapter::RexmlAdapter
+  end
+end

data/spec/lutaml/xml/adapter/order_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+require "lutaml/model"
+require "lutaml/xml"
+require "lutaml/xml/adapter/nokogiri_adapter"
+require "lutaml/xml/adapter/ox_adapter"
+require "lutaml/xml/adapter/oga_adapter"
+require "lutaml/xml/adapter/rexml_adapter"
+
+module XmlAdapterSharedFeaturesSpec
+  class ProcessingInstructionLookupElement < Lutaml::Model::Serializable
+    attribute :foo, :string
+
+    xml do
+      root "root"
+      map_element "foo", to: :foo
+    end
+  end
+end
+
+RSpec.describe "XML adapter order metadata" do
+  shared_examples "consistent order metadata" do |adapter_class|
+    let(:xml) do
+      "<root>before<![CDATA[cdata text]]><?pi data?><child/>after</root>"
+    end
+
+    let(:document) { adapter_class.parse(xml) }
+
+    let(:expected_order) do
+      [
+        ["Text", "text", :text, "before"],
+        ["Text", "#cdata-section", :cdata, "cdata text"],
+        ["ProcessingInstruction", "pi", :processing_instruction, "data"],
+        ["Element", "child", :element, nil],
+        ["Text", "text", :text, "after"],
+      ]
+    end
+
+    def order_data(order)
+      order.map do |item|
+        [item.type, item.name, item.node_type, item.text_content]
+      end
+    end
+
+    it "uses the same order representation for root, document, and class order" do
+      expect(order_data(document.root.order)).to eq(expected_order)
+      expect(order_data(document.order)).to eq(expected_order)
+      expect(order_data(adapter_class.order_of(document.root))).to eq(expected_order)
+    end
+
+    it "parses processing instructions as first-class XML nodes" do
+      instruction = document.root.children.find(&:processing_instruction?)
+
+      expect(instruction).not_to be_nil
+      expect(instruction.name).to eq("pi")
+      expect(instruction.text).to eq("data")
+      expect(instruction.node_type).to eq(:processing_instruction)
+    end
+
+    it "preserves processing instructions and CDATA when serializing parsed XML" do
+      output = document.to_xml
+
+      expect(output).to include("<?pi data?>")
+      expect(output).to include("<![CDATA[cdata text]]>")
+    end
+
+    it "uses the same order representation through to_h item_order" do
+      parsed_hash = nil
+
+      expect { parsed_hash = document.to_h }.not_to raise_error
+      expect(order_data(parsed_hash.item_order)).to eq(expected_order)
+    end
+  end
+
+  shared_examples "consistent shared adapter features" 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 "uses shared parse metadata preservation" do
+      xml = <<~XML
+        <?xml version="1.0"?>
+        <!DOCTYPE root SYSTEM "root.dtd">
+        <root><child/></root>
+      XML
+
+      document = adapter_class.parse(xml)
+
+      expect(document.xml_declaration[:had_declaration]).to be true
+      expect(document.doctype).to include(name: "root",
+                                          public_id: nil,
+                                          system_id: "root.dtd")
+      expect(document.to_xml(declaration: true)).to include(
+        '<!DOCTYPE root SYSTEM "root.dtd">',
+      )
+    end
+
+    it "parses binary UTF-8 XML input through shared normalization" do
+      document = adapter_class.parse("<root><name>μ</name></root>".b)
+
+      expect(document.root.name).to eq("root")
+      expect(document.root.element_children.first.text).to eq("μ")
+    end
+
+    it "transcodes non-UTF-8 strings from their declared encoding" do
+      xml = "<root><name>\xC2\xA3</name></root>".b
+      xml.force_encoding("ISO-8859-1")
+      document = adapter_class.parse(xml)
+
+      expect(document.root.element_children.first.text).to eq("£")
+    end
+
+    it "preserves processing instructions without matching them as elements" do
+      xml = "<root><?foo ignored?><foo>bar</foo></root>"
+      document = adapter_class.parse(xml)
+
+      expect(document.root.children.any?(&:processing_instruction?)).to be true
+      expect(document.root.element_children.map(&:text)).to eq(["bar"])
+      expect(document.root.find_children_by_name("foo").map(&:text)).to eq(["bar"])
+      expect(
+        XmlAdapterSharedFeaturesSpec::ProcessingInstructionLookupElement
+          .from_xml(xml)
+          .foo,
+      ).to eq("bar")
+    end
+  end
+
+  describe Lutaml::Xml::Adapter::NokogiriAdapter do
+    it_behaves_like "consistent order metadata", described_class
+    it_behaves_like "consistent shared adapter features", described_class
+  end
+
+  describe Lutaml::Xml::Adapter::OxAdapter do
+    it_behaves_like "consistent order metadata", described_class
+    it_behaves_like "consistent shared adapter features", described_class
+  end
+
+  describe Lutaml::Xml::Adapter::OgaAdapter do
+    it_behaves_like "consistent order metadata", described_class
+    it_behaves_like "consistent shared adapter features", described_class
+  end
+
+  describe Lutaml::Xml::Adapter::RexmlAdapter do
+    it_behaves_like "consistent order metadata", described_class
+    it_behaves_like "consistent shared adapter features", described_class
+  end
+end