lutaml-model 0.8.16 → 0.8.18

data/spec/lutaml/xml/serializable_namespace_spec.rb

@@ -22,7 +22,7 @@ RSpec.describe Lutaml::Model::Serializable, "namespace directive" do
       model_class = Class.new do
         include Lutaml::Model::Serialize
       end
-      model_class.namespace(test_namespace)
+      expect { model_class.namespace(test_namespace) }.to output.to_stderr
 
       expect(model_class.namespace).to eq(test_namespace)
     end
@@ -49,7 +49,7 @@ RSpec.describe Lutaml::Model::Serializable, "namespace directive" do
       model_class = Class.new do
         include Lutaml::Model::Serialize
       end
-      model_class.namespace(test_namespace)
+      expect { model_class.namespace(test_namespace) }.to output.to_stderr
       model_class.namespace(other_namespace)
 
       expect(model_class.namespace).to eq(other_namespace)
@@ -61,7 +61,7 @@ RSpec.describe Lutaml::Model::Serializable, "namespace directive" do
       model_class = Class.new do
         include Lutaml::Model::Serialize
       end
-      model_class.namespace(test_namespace)
+      expect { model_class.namespace(test_namespace) }.to output.to_stderr
 
       expect(model_class.namespace_uri).to eq("https://example.com/model")
     end
@@ -80,7 +80,7 @@ RSpec.describe Lutaml::Model::Serializable, "namespace directive" do
       model_class = Class.new do
         include Lutaml::Model::Serialize
       end
-      model_class.namespace(test_namespace)
+      expect { model_class.namespace(test_namespace) }.to output.to_stderr
 
       expect(model_class.namespace_prefix).to eq("model")
     end
@@ -103,7 +103,7 @@ RSpec.describe Lutaml::Model::Serializable, "namespace directive" do
         attribute :value, :integer
       end
 
-      model_class.namespace(test_namespace)
+      expect { model_class.namespace(test_namespace) }.to output.to_stderr
 
       expect(model_class.namespace).to eq(test_namespace)
       expect(model_class.attributes.keys).to include(:name, :value)
@@ -113,7 +113,7 @@ RSpec.describe Lutaml::Model::Serializable, "namespace directive" do
       parent_class = Class.new do
         include Lutaml::Model::Serialize
       end
-      parent_class.namespace(test_namespace)
+      expect { parent_class.namespace(test_namespace) }.to output.to_stderr
 
       child_class = Class.new(parent_class)
 

data/spec/lutaml/xml/type_namespace_examples_spec.rb

@@ -453,7 +453,7 @@ RSpec.describe "Type Namespace Examples" do
       serialized = props.to_xml
 
       # xsi:type attribute should use xsi: namespace from XsiTypeType
-      expect(serialized).to match(/xsi:type="dcterms:W3CDTF"/)
+      expect(serialized).to include('xsi:type="dcterms:W3CDTF"')
     end
 
     it "handles multiple Type namespaces in single document" do

data/spec/lutaml/xml/type_namespace_integration_spec.rb

@@ -189,8 +189,8 @@ RSpec.describe "Type-level namespace integration" do
       expect(xml).to include('id="doc1"')
       expect(xml).to include('title="Test"')
       # Should not have any namespace prefix
-      expect(xml).not_to match(/:id=/)
-      expect(xml).not_to match(/:title=/)
+      expect(xml).not_to include(":id=")
+      expect(xml).not_to include(":title=")
     end
   end
 
@@ -268,11 +268,11 @@ RSpec.describe "Type-level namespace integration" do
       document_class = Class.new do
         include Lutaml::Model::Serialize
 
-        namespace model_namespace
         attribute :special_field, special_type
 
         xml do
           element "document"
+          namespace model_namespace
           map_element "special_field", to: :special_field
         end
 

data/spec/lutaml/xml/validate_xml_with_constructs_spec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "validate_xml_with XSD constructs" do
+  def fixture_path(name)
+    File.expand_path("../../fixtures/xml/#{name}", __dir__)
+  end
+
+  describe "kitchen-sink schema (pattern, enumeration, attributes, " \
+           "types, occurrence, nested complex type)" do
+    before do
+      path = fixture_path("validate_xml_with_product.xsd")
+
+      stub_const("XsdDimensions", Class.new(Lutaml::Model::Serializable) do
+        attribute :width, :string
+        attribute :height, :string
+
+        xml do
+          element "dimensions"
+          map_element "width", to: :width
+          map_element "height", to: :height
+        end
+      end)
+
+      stub_const("XsdProduct", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        attribute :status, :string
+        attribute :sku, :string
+        attribute :price, :string
+        attribute :released, :string
+        attribute :tags, :string, collection: true
+        attribute :note, :string
+        attribute :dimensions, XsdDimensions
+
+        xml do
+          element "product"
+          map_attribute "id", to: :id
+          map_attribute "status", to: :status
+          map_element "sku", to: :sku
+          map_element "price", to: :price
+          map_element "released", to: :released
+          map_element "tag", to: :tags
+          map_element "note", to: :note
+          map_element "dimensions", to: :dimensions
+        end
+
+        validate_xml_with path
+      end)
+    end
+
+    let(:valid_attributes) do
+      {
+        id: "p1",
+        status: "published",
+        sku: "ABC-1234",
+        price: "9.99",
+        released: "2026-06-11",
+        tags: %w[a b c],
+        note: "boundary case: three tags is maxOccurs",
+        dimensions: XsdDimensions.new(width: "10", height: "20"),
+      }
+    end
+
+    def product(**overrides)
+      XsdProduct.new(valid_attributes.merge(overrides))
+    end
+
+    it "accepts a document satisfying every construct" do
+      expect(product.validate).to be_empty
+    end
+
+    it "accepts a document omitting all optional parts" do
+      minimal = product(status: nil, tags: [], note: nil, dimensions: nil)
+
+      expect(minimal.validate).to be_empty
+    end
+
+    it "collects xs:pattern violations" do
+      errors = product(sku: "bad-sku").validate
+
+      expect(errors.map(&:message)).to include(a_string_including("sku"))
+    end
+
+    it "collects xs:enumeration violations" do
+      errors = product(status: "archived").validate
+
+      expect(errors.map(&:message)).to include(a_string_including("status"))
+    end
+
+    it "collects missing required attribute violations" do
+      errors = product(id: nil).validate
+
+      expect(errors.map(&:message)).to include(
+        a_string_including("attribute 'id' is required"),
+      )
+    end
+
+    it "collects xs:decimal lexical violations" do
+      errors = product(price: "free").validate
+
+      expect(errors.map(&:message)).to include(a_string_including("price"))
+    end
+
+    it "collects xs:date lexical violations" do
+      errors = product(released: "tomorrow").validate
+
+      expect(errors.map(&:message)).to include(a_string_including("released"))
+    end
+
+    it "collects maxOccurs violations" do
+      errors = product(tags: %w[a b c d]).validate
+
+      expect(errors.map(&:message)).to include(a_string_including("tag"))
+    end
+
+    it "collects violations inside nested complex types" do
+      bad_nested = XsdDimensions.new(width: "wide", height: "20")
+      errors = product(dimensions: bad_nested).validate
+
+      expect(errors.map(&:message)).to include(a_string_including("width"))
+    end
+  end
+
+  describe "multiple schema paths" do
+    before do
+      base = fixture_path("validate_xml_with_person.xsd")
+      strict = fixture_path("validate_xml_with_person_strict.xsd")
+
+      stub_const("XsdDualSchemaPerson",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :name, :string
+                   attribute :age, :string
+
+                   xml do
+                     element "person"
+                     map_element "name", to: :name
+                     map_element "age", to: :age
+                   end
+
+                   validate_xml_with base, strict
+                 end)
+    end
+
+    it "passes when the document conforms to every schema" do
+      person = XsdDualSchemaPerson.new(name: "Alice", age: "30")
+
+      expect(person.validate).to be_empty
+    end
+
+    it "attributes violations to the schema that rejected the document" do
+      person = XsdDualSchemaPerson.new(name: "Old", age: "200")
+      errors = person.validate
+
+      expect(errors.size).to eq(1)
+      expect(errors.first.schema_path).to eq(
+        fixture_path("validate_xml_with_person_strict.xsd"),
+      )
+    end
+  end
+
+  describe "targetNamespace with qualified elements" do
+    let(:schema_path) { fixture_path("validate_xml_with_address.xsd") }
+
+    before do
+      path = schema_path
+      stub_const("XsdNamespacedDoc",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :city, :string
+
+                   xml do
+                     element "address"
+                     map_element "city", to: :city
+                   end
+
+                   validate_xml_with path
+                 end)
+    end
+
+    it "accepts a document in the target namespace" do
+      xml = '<address xmlns="http://example.com/address">' \
+            "<city>Berlin</city></address>"
+
+      expect(XsdNamespacedDoc.validate_xml(xml)).to be_empty
+    end
+
+    it "rejects a document missing the target namespace" do
+      xml = "<address><city>Berlin</city></address>"
+
+      expect(XsdNamespacedDoc.validate_xml(xml)).not_to be_empty
+    end
+  end
+
+  describe "xs:choice" do
+    before do
+      path = fixture_path("validate_xml_with_contact.xsd")
+      stub_const("XsdChoiceDoc",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :email, :string
+
+                   xml do
+                     element "contact"
+                     map_element "email", to: :email
+                   end
+
+                   validate_xml_with path
+                 end)
+    end
+
+    it "accepts a document using exactly one branch" do
+      xml = "<contact><email>a@b.c</email></contact>"
+
+      expect(XsdChoiceDoc.validate_xml(xml)).to be_empty
+    end
+
+    it "rejects a document using both branches" do
+      xml = "<contact><email>a@b.c</email><phone>123</phone></contact>"
+
+      expect(XsdChoiceDoc.validate_xml(xml)).not_to be_empty
+    end
+  end
+end

data/spec/lutaml/xml/validate_xml_with_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+RSpec.describe "validate_xml_with" do
+  let(:schema_path) do
+    File.expand_path("../../fixtures/xml/validate_xml_with_person.xsd",
+                     __dir__)
+  end
+
+  before do
+    path = schema_path
+    stub_const("XsdValidatedPerson",
+               Class.new(Lutaml::Model::Serializable) do
+                 attribute :name, :string
+                 attribute :age, :string
+
+                 xml do
+                   element "person"
+                   map_element "name", to: :name
+                   map_element "age", to: :age
+                 end
+
+                 validate_xml_with path
+               end)
+  end
+
+  context "when the generated XML conforms to the schema" do
+    let(:person) { XsdValidatedPerson.new(name: "Alice", age: "30") }
+
+    it "returns no errors from validate" do
+      expect(person.validate).to be_empty
+    end
+
+    it "does not raise on validate!" do
+      expect { person.validate! }.not_to raise_error
+    end
+  end
+
+  context "when the generated XML violates the schema" do
+    let(:person) { XsdValidatedPerson.new(name: "Alice", age: "abc") }
+
+    it "collects schema validation errors" do
+      errors = person.validate
+
+      expect(errors).to all(
+        be_a(Lutaml::Xml::Error::SchemaValidationError),
+      )
+      expect(errors.first.message).to include(schema_path)
+    end
+
+    it "raises ValidationError with the schema message on validate!" do
+      expect { person.validate! }.to raise_error(
+        Lutaml::Model::ValidationError,
+        /age/,
+      )
+    end
+  end
+
+  describe ".validate_xml / .validate_xml!" do
+    let(:valid_xml) do
+      "<person><name>Alice</name><age>30</age></person>"
+    end
+    let(:invalid_xml) do
+      "<person><name>Alice</name><age>abc</age></person>"
+    end
+
+    it "returns no errors for a conforming raw XML string" do
+      expect(XsdValidatedPerson.validate_xml(valid_xml)).to be_empty
+    end
+
+    it "collects errors for a non-conforming raw XML string" do
+      errors = XsdValidatedPerson.validate_xml(invalid_xml)
+
+      expect(errors).to all(
+        be_a(Lutaml::Xml::Error::SchemaValidationError),
+      )
+    end
+
+    it "raises ValidationError for a non-conforming raw XML string" do
+      expect do
+        XsdValidatedPerson.validate_xml!(invalid_xml)
+      end.to raise_error(Lutaml::Model::ValidationError, /age/)
+    end
+
+    it "raises a parse error for malformed XML instead of recovering" do
+      expect do
+        XsdValidatedPerson.validate_xml("<person><name>Alice</name>")
+      end.to raise_error(Nokogiri::XML::SyntaxError)
+    end
+  end
+
+  context "with schema path inheritance" do
+    before do
+      stub_const("XsdValidatedEmployee", Class.new(XsdValidatedPerson))
+      stub_const("XsdAugmentedEmployee",
+                 Class.new(XsdValidatedPerson) do
+                   validate_xml_with "extra/employee.xsd"
+                 end)
+    end
+
+    it "subclasses inherit the parent's schema" do
+      employee = XsdValidatedEmployee.new(name: "Bob", age: "abc")
+
+      expect(employee.validate).not_to be_empty
+    end
+
+    it "a subclass macro call appends parent-first" do
+      expect(XsdAugmentedEmployee.xml_schema_paths).to eq(
+        [schema_path, File.expand_path("extra/employee.xsd", __dir__)],
+      )
+    end
+
+    it "does not leak child paths back to the parent" do
+      expect(XsdValidatedPerson.xml_schema_paths).to eq([schema_path])
+    end
+  end
+
+  context "with a schema path relative to the declaring file" do
+    before do
+      stub_const("RelativeSchemaPerson",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :name, :string
+                   attribute :age, :string
+
+                   xml do
+                     element "person"
+                     map_element "name", to: :name
+                     map_element "age", to: :age
+                   end
+
+                   validate_xml_with(
+                     "../../fixtures/xml/validate_xml_with_person.xsd",
+                   )
+                 end)
+    end
+
+    it "resolves the schema next to the declaring file, not the CWD" do
+      Dir.chdir(Dir.tmpdir) do
+        person = RelativeSchemaPerson.new(name: "Alice", age: "abc")
+
+        expect(person.validate).not_to be_empty
+      end
+    end
+  end
+
+  context "when no schema is configured" do
+    before do
+      stub_const("PlainPerson", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        xml do
+          element "person"
+          map_element "name", to: :name
+        end
+      end)
+    end
+
+    it "validates without touching XSD machinery" do
+      expect(PlainPerson.new(name: "Alice").validate).to be_empty
+    end
+  end
+
+  context "when the schema file does not exist" do
+    before do
+      stub_const("MissingSchemaPerson",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :name, :string
+
+                   xml do
+                     element "person"
+                     map_element "name", to: :name
+                   end
+
+                   validate_xml_with "nonexistent/schema.xsd"
+                 end)
+    end
+
+    it "raises a configuration-level error" do
+      expect do
+        MissingSchemaPerson.new(name: "Alice").validate
+      end.to raise_error(Errno::ENOENT)
+    end
+  end
+end

data/spec/lutaml/yamlld/adapter_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/yamlld"
+
+RSpec.describe Lutaml::YamlLd::Adapter do
+  let(:yamlld_hash) do
+    {
+      "@context" => { "name" => "http://example.org/name" },
+      "@type" => "Thing",
+      "name" => "test",
+    }
+  end
+
+  describe ".parse" do
+    it "parses valid YAML-LD string to hash" do
+      yaml = YAML.dump(yamlld_hash)
+      result = described_class.parse(yaml)
+      expect(result).to eq(yamlld_hash)
+    end
+  end
+
+  describe "#to_yamlld" do
+    it "generates YAML-LD string from hash" do
+      adapter = described_class.new(yamlld_hash)
+      result = adapter.to_yamlld
+      parsed = YAML.safe_load(result)
+      expect(parsed["@context"]).to eq({ "name" => "http://example.org/name" })
+    end
+  end
+
+  it "round-trips parse → generate" do
+    yaml = YAML.dump(yamlld_hash)
+    parsed = described_class.parse(yaml)
+    adapter = described_class.new(parsed)
+    result = adapter.to_yamlld
+    round_tripped = YAML.safe_load(result)
+    expect(round_tripped).to eq(yamlld_hash)
+  end
+
+  describe "safe_load enforcement" do
+    it "rejects YAML with disallowed class tags" do
+      unsafe = "--- !ruby/object:Object {}\n"
+      expect do
+        described_class.parse(unsafe)
+      end.to raise_error(Psych::DisallowedClass)
+    end
+
+    it "rejects malformed YAML with Psych::SyntaxError" do
+      malformed = "@context: [unterminated"
+      expect do
+        described_class.parse(malformed)
+      end.to raise_error(Psych::SyntaxError)
+    end
+  end
+end

data/spec/lutaml/yamlld/registration_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/jsonld"
+require "lutaml/yamlld"
+
+RSpec.describe ":yamlld format registration" do
+  it "is registered with FormatRegistry as an RDF format" do
+    expect(Lutaml::Model::FormatRegistry.rdf_formats).to include(:yamlld)
+  end
+
+  it "uses Rdf::Mapping as the mapping class" do
+    expect(Lutaml::Model::FormatRegistry.mappings_class_for(:yamlld))
+      .to eq(Lutaml::Rdf::Mapping)
+  end
+
+  it "uses YamlLd::Adapter as the adapter class" do
+    expect(Lutaml::Model::FormatRegistry.adapter_class_for(:yamlld))
+      .to eq(Lutaml::YamlLd::Adapter)
+  end
+
+  it "shares LinkedDataTransform with :jsonld" do
+    expect(Lutaml::Model::FormatRegistry.transformer_for(:yamlld))
+      .to eq(Lutaml::Rdf::LinkedDataTransform)
+    expect(Lutaml::Model::FormatRegistry.transformer_for(:yamlld))
+      .to eq(Lutaml::Model::FormatRegistry.transformer_for(:jsonld))
+  end
+
+  it "declares Psych::SyntaxError as a parse error type" do
+    expect(Lutaml::Model::FormatRegistry.error_types_for(:yamlld))
+      .to include("Psych::SyntaxError")
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "liquid"
+require "liquid" unless RUBY_ENGINE == "opal"
 require "rspec/matchers"
-require "canon"
+require "canon" unless RUBY_ENGINE == "opal"
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
@@ -71,11 +71,27 @@ RSpec.configure do |config|
 
     end
   end
+
+  # Under Opal, exclude specs that require native-only adapters,
+  # filesystem, subprocess, schema compilation, or liquid templates.
+  if RUBY_ENGINE == "opal"
+    config.filter_run_excluding(
+      :native_adapter,
+      :native_fs,
+      :subprocess,
+      :performance,
+      :examples,
+      :consistency,
+      :xsd_schema,
+      :relaxng,
+      :liquid,
+    )
+  end
 end
 
 # configuration example
-require_relative "../lib/lutaml/model"
-require_relative "../lib/lutaml/xml"
+require "lutaml/model"
+require "lutaml/xml"
 require_relative "support/test_namespaces"
 require_relative "support/test_adapter_config"
 # require_relative "../lib/lutaml/xml/adapter/nokogiri_adapter"
@@ -83,16 +99,17 @@ require_relative "support/test_adapter_config"
 # require_relative "../lib/lutaml/model/toml_adapter/toml_rb_adapter"
 
 Lutaml::Model::Config.configure do |config|
-  config.xml_adapter_type = :nokogiri
+  config.xml_adapter_type  = RUBY_ENGINE == "opal" ? :oga : :nokogiri
   config.hash_adapter_type = :standard
   config.json_adapter_type = :standard
   config.yaml_adapter_type = :standard
-  config.toml_adapter_type = :toml_rb
+  # toml_rb uses native ext; not registered as a lutaml format under Opal.
+  config.toml_adapter_type = :toml_rb unless RUBY_ENGINE == "opal"
 end
 
-# Configure Canon for XML equivalence testing
-# Use spec_friendly profile which includes structural_whitespace: :ignore
-# This allows pretty-printed XML to be compared with compact XML
-Canon::Config.configure do |config|
-  config.xml.match.profile = :spec_friendly
+# Configure Canon for XML equivalence testing (Canon is not loaded under Opal)
+if defined?(Canon::Config)
+  Canon::Config.configure do |config|
+    config.xml.match.profile = :spec_friendly
+  end
 end

data/spec/support/opal.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-# Opal runtime patches for lutaml-model specs
+# Opal runtime patches for lutaml-model specs.
+# Oga (via moxml's vendored opal-oga fork) is the default XML adapter
+# under Opal; REXML (bundled stdlib gem, pure Ruby) is also available.
+# Smoke specs parameterize over both — see spec/lutaml/xml/opal_xml_spec.rb.
 if RUBY_ENGINE == "opal"
-  Lutaml::Model::Config.xml_adapter_type = :rexml
+  Lutaml::Model::Config.xml_adapter_type = :oga
 end