lutaml-model 0.8.16 → 0.8.18

data/spec/lutaml/model/union_spec.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module UnionSpec
+  class WithUnit < Lutaml::Model::Serializable
+    attribute :number, :float
+    attribute :unit, :string
+
+    key_value do
+      map "number", to: :number
+      map "unit", to: :unit
+    end
+  end
+
+  class Celsius < Lutaml::Model::Serializable
+    attribute :celsius, :float
+
+    key_value do
+      map "celsius", to: :celsius
+    end
+  end
+
+  # Member declaring an aliased key (two names for one attribute).
+  class AliasedName < Lutaml::Model::Serializable
+    attribute :name, :string
+
+    key_value do
+      map %w[name product_name], to: :name
+    end
+  end
+end
+
+RSpec.describe Lutaml::Model::Type::Union do
+  let(:int_str) do
+    [Lutaml::Model::Type::Integer, Lutaml::Model::Type::String]
+  end
+  let(:int_float) do
+    [Lutaml::Model::Type::Integer, Lutaml::Model::Type::Float]
+  end
+
+  def member_for(value, members, format: nil)
+    result = described_class.conforming_member(value, members,
+                                               format: format, register: nil)
+    result&.first
+  end
+
+  describe ".conforming_member (scalars)" do
+    it "matches Integer for an integer-lexical string" do
+      expect(member_for("42", int_str)).to eq(Lutaml::Model::Type::Integer)
+    end
+
+    it "falls through to String when Integer rejects" do
+      expect(member_for("hello", int_str)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "rejects a float-string for Integer (sound predicate, not Integer('3.7'))" do
+      expect(member_for("3.7", int_float)).to eq(Lutaml::Model::Type::Float)
+    end
+
+    it "accepts a numeric integer string for the Integer member first" do
+      expect(member_for("1300", int_float)).to eq(Lutaml::Model::Type::Integer)
+    end
+
+    it "matches a native Integer value" do
+      expect(member_for(42, int_str)).to eq(Lutaml::Model::Type::Integer)
+    end
+
+    it "matches a native Float value to the Float member" do
+      expect(member_for(3.7, int_float)).to eq(Lutaml::Model::Type::Float)
+    end
+
+    it "returns nil when no scalar member conforms" do
+      expect(member_for("abc", int_float)).to be_nil
+    end
+
+    it "rejects an Integer that Float cannot represent exactly" do
+      expect(member_for((2**60) + 1, [Lutaml::Model::Type::Float])).to be_nil
+    end
+
+    it "widens a Float-representable Integer into Float" do
+      member, casted = described_class.conforming_member(
+        2**60, [Lutaml::Model::Type::Float], format: nil, register: nil
+      )
+      expect([member, casted]).to eq([Lutaml::Model::Type::Float, (2**60).to_f])
+    end
+
+    it "casts the value to the matched member" do
+      member, casted = described_class.conforming_member(
+        "42", int_str, format: nil, register: nil
+      )
+      expect([member, casted]).to eq([Lutaml::Model::Type::Integer, 42])
+    end
+  end
+
+  describe ".conforming_member (boolean lexical space)" do
+    let(:bool_str) do
+      [Lutaml::Model::Type::Boolean, Lutaml::Model::Type::String]
+    end
+
+    it "matches a true/false word to Boolean" do
+      expect(member_for("true", bool_str))
+        .to eq(Lutaml::Model::Type::Boolean)
+    end
+
+    it "falls through to String for a non-boolean word" do
+      expect(member_for("maybe", bool_str))
+        .to eq(Lutaml::Model::Type::String)
+    end
+  end
+
+  describe ".conforming_member (models by key-coverage)" do
+    let(:members) { [UnionSpec::WithUnit, UnionSpec::Celsius] }
+
+    it "selects the model whose fields cover the input keys" do
+      member, = described_class.conforming_member(
+        { "number" => 1300.0, "unit" => "C" }, members,
+        format: :yaml, register: nil
+      )
+      expect(member).to eq(UnionSpec::WithUnit)
+    end
+
+    it "selects the disjoint-key model" do
+      member, = described_class.conforming_member(
+        { "celsius" => 1200.0 }, members, format: :yaml, register: nil
+      )
+      expect(member).to eq(UnionSpec::Celsius)
+    end
+
+    it "deserializes the selected model member" do
+      _, value = described_class.conforming_member(
+        { "celsius" => 1200.0 }, members, format: :yaml, register: nil
+      )
+      expect(value).to be_a(UnionSpec::Celsius)
+      expect(value.celsius).to eq(1200.0)
+    end
+
+    it "returns nil when no model covers the keys" do
+      result = described_class.conforming_member(
+        { "unknown" => 1 }, members, format: :yaml, register: nil
+      )
+      expect(result).to be_nil
+    end
+
+    it "selects a member matched through an aliased key" do
+      member, value = described_class.conforming_member(
+        { "product_name" => "Vase" }, [UnionSpec::AliasedName],
+        format: :yaml, register: nil
+      )
+      expect(member).to eq(UnionSpec::AliasedName)
+      expect(value.name).to eq("Vase")
+    end
+
+    it "returns an existing member instance unchanged (idempotent)" do
+      instance = UnionSpec::Celsius.new(celsius: 1200.0)
+      member, value = described_class.conforming_member(
+        instance, members, format: :yaml, register: nil
+      )
+      expect(member).to eq(UnionSpec::Celsius)
+      expect(value).to be(instance)
+    end
+  end
+
+  describe "nil passthrough" do
+    it "returns nil for nil input" do
+      expect(member_for(nil, int_str)).to be_nil
+    end
+  end
+
+  describe ".validate_members!" do
+    it "raises on an empty member list" do
+      expect { described_class.validate_members!([]) }
+        .to raise_error(ArgumentError)
+    end
+
+    it "raises when a member is not a valid type" do
+      expect { described_class.validate_members!([Object]) }
+        .to raise_error(ArgumentError)
+    end
+
+    it "raises when a catch-all is not last" do
+      expect do
+        described_class.validate_members!(
+          [Lutaml::Model::Type::String, Lutaml::Model::Type::Integer],
+        )
+      end.to raise_error(ArgumentError)
+    end
+
+    it "accepts a valid ordered member list" do
+      expect do
+        described_class.validate_members!(
+          [Lutaml::Model::Type::Integer, Lutaml::Model::Type::String],
+        )
+      end.not_to raise_error
+    end
+  end
+
+  describe ".validate_combo!" do
+    it "raises when combined with polymorphic" do
+      expect { described_class.validate_combo!(polymorphic: {}) }
+        .to raise_error(ArgumentError)
+    end
+
+    it "raises when combined with raw" do
+      expect { described_class.validate_combo!(raw: true) }
+        .to raise_error(ArgumentError)
+    end
+
+    it "accepts a plain options hash" do
+      expect { described_class.validate_combo!(collection: true) }
+        .not_to raise_error
+    end
+  end
+
+  describe "schema export" do
+    let(:klass) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :v,
+                  [Lutaml::Model::Type::Integer, Lutaml::Model::Type::String]
+        xml do
+          element "union_schema_sample"
+          map_element "v", to: :v
+        end
+        key_value { map "v", to: :v }
+
+        def self.name
+          "UnionSchemaSample"
+        end
+      end
+    end
+
+    it "emits anyOf for JSON Schema (valid if at least one member matches)" do
+      schema = JSON.parse(Lutaml::Model::Schema::JsonSchema.generate(klass))
+      defs = schema["$defs"] || schema["definitions"] || {}
+      property = defs.dig("UnionSchemaSample", "properties", "v") ||
+        schema.dig("properties", "v")
+
+      expect(property).to eq(
+        "anyOf" => [
+          { "type" => "integer" },
+          { "type" => "string" },
+          { "type" => "null" },
+        ],
+      )
+    end
+
+    it "raises UnionSchemaUnsupportedError for XSD" do
+      expect { Lutaml::Xml::Schema::XsdSchema.generate(klass) }
+        .to raise_error(Lutaml::Model::UnionSchemaUnsupportedError)
+    end
+
+    it "raises UnionSchemaUnsupportedError for RelaxNG" do
+      expect { Lutaml::Xml::Schema::RelaxngSchema.generate(klass) }
+        .to raise_error(Lutaml::Model::UnionSchemaUnsupportedError)
+    end
+  end
+end

data/spec/lutaml/model/utils_spec.rb

@@ -56,6 +56,20 @@ RSpec.describe Lutaml::Model::Utils do
   it_behaves_like "string conversion", :snake_case, SNAKE_CASE_EXAMPLES
   it_behaves_like "string conversion", :pluralize, PLURALIZE_EXAMPLES
 
+  describe ".last_of_split" do
+    it "returns the segment after the colon" do
+      expect(utils.last_of_split("foo:Bar")).to eq("Bar")
+    end
+
+    it "returns the input unchanged when there is no colon" do
+      expect(utils.last_of_split("Bar")).to eq("Bar")
+    end
+
+    it "returns nil for nil input" do
+      expect(utils.last_of_split(nil)).to be_nil
+    end
+  end
+
   describe ".deep_dup" do
     let(:original_hash) do
       {

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

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")

data/spec/lutaml/turtle/transform_spec.rb

@@ -119,13 +119,13 @@ RSpec.describe Lutaml::Turtle::Transform do
     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/)
+      expect(result).to include("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/)
+      expect(result).to include("skos:note true")
     end
   end
 

data/spec/lutaml/xml/enhanced_mapping_spec.rb

@@ -187,6 +187,235 @@ RSpec.describe "Enhanced XML Mapping Features" do
         expect(name_rule.form).to eq(:unqualified)
       end
     end
+
+    context "with Serializable child and form: :qualified" do
+      # Regression: form option on the parent's map_element rule must be
+      # propagated to the child XmlElement when the child is a Serializable
+      # (which goes through create_transformed_nested_element). Otherwise the
+      # ElementFormOptionRule cannot fire and the element is serialized
+      # without the namespace prefix.
+      let(:child_class) do
+        ns = namespace_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :label, :string
+
+          xml do
+            element "child"
+            namespace ns
+            map_element "label", to: :label
+          end
+        end
+      end
+
+      let(:model_class) do
+        ns = namespace_class
+        child = child_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :child, child
+
+          xml do
+            element "item"
+            namespace ns
+            map_element "child", to: :child, form: :qualified
+          end
+        end
+      end
+
+      it "stores form: :qualified on the parent rule" do
+        mapping = model_class.mappings_for(:xml)
+        child_rule = mapping.find_element(:child)
+        expect(child_rule.form).to eq(:qualified)
+      end
+
+      it "serializes the nested Serializable with a namespace prefix" do
+        instance = model_class.new(child: child_class.new(label: "x"))
+        doc = Nokogiri::XML(instance.to_xml)
+        qualified = doc.at_xpath("//*[name()='ex:child']")
+        expect(qualified).not_to be_nil
+        expect(qualified.at_xpath("./xmlns:label").text).to eq("x")
+      end
+
+      it "round-trips the qualified Serializable child" do
+        original = model_class.new(child: child_class.new(label: "round-trip"))
+        restored = model_class.from_xml(original.to_xml)
+        expect(restored.child.label).to eq("round-trip")
+      end
+    end
+
+    context "with Serializable child and form: :unqualified" do
+      # Symmetric to the :qualified case: form: :unqualified must propagate
+      # to the child XmlElement so ElementFormOptionRule can force the
+      # default (unprefixed) form.
+      let(:child_class) do
+        ns = namespace_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :label, :string
+
+          xml do
+            element "child"
+            namespace ns
+            map_element "label", to: :label
+          end
+        end
+      end
+
+      let(:model_class) do
+        ns = namespace_class
+        child = child_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :child, child
+
+          xml do
+            element "item"
+            namespace ns
+            map_element "child", to: :child, form: :unqualified
+          end
+        end
+      end
+
+      it "propagates form: :unqualified and emits an unprefixed child" do
+        instance = model_class.new(child: child_class.new(label: "x"))
+        doc = Nokogiri::XML(instance.to_xml)
+        expect(doc.xpath("//*[name()='ex:child']")).to be_empty
+        expect(doc.at_xpath("//*[local-name()='child']")).not_to be_nil
+      end
+    end
+
+    context "with a collection of Serializable children" do
+      # The form option must propagate to every element produced for a
+      # collection attribute, not just the first.
+      let(:child_class) do
+        ns = namespace_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :label, :string
+
+          xml do
+            element "child"
+            namespace ns
+            map_element "label", to: :label
+          end
+        end
+      end
+
+      let(:model_class) do
+        ns = namespace_class
+        child = child_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :children, child, collection: true
+
+          xml do
+            element "item"
+            namespace ns
+            map_element "child", to: :children, form: :qualified
+          end
+        end
+      end
+
+      it "qualifies every child in the collection" do
+        instance = model_class.new(
+          children: [child_class.new(label: "a"), child_class.new(label: "b")],
+        )
+        doc = Nokogiri::XML(instance.to_xml)
+        qualified = doc.xpath("//*[name()='ex:child']")
+        labels = qualified.map { |c| c.at_xpath("./xmlns:label").text }
+        expect(labels).to contain_exactly("a", "b")
+      end
+    end
+
+    context "with a Serializable child containing a Serializable grandchild" do
+      # form: :qualified is a per-rule override; it must NOT propagate
+      # transitively to grandchildren. Each level applies its own rule and
+      # its own parent_element_form_default.
+      let(:grandchild_class) do
+        ns = namespace_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :value, :string
+
+          xml do
+            element "grandchild"
+            namespace ns
+            map_element "value", to: :value
+          end
+        end
+      end
+
+      let(:child_class) do
+        ns = namespace_class
+        grandchild = grandchild_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :inner, grandchild
+
+          xml do
+            element "child"
+            namespace ns
+            map_element "grandchild", to: :inner
+          end
+        end
+      end
+
+      let(:model_class) do
+        ns = namespace_class
+        child = child_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :child, child
+
+          xml do
+            element "item"
+            namespace ns
+            map_element "child", to: :child, form: :qualified
+          end
+        end
+      end
+
+      it "qualifies the child but leaves the grandchild unprefixed" do
+        instance = model_class.new(
+          child: child_class.new(inner: grandchild_class.new(value: "x")),
+        )
+        doc = Nokogiri::XML(instance.to_xml)
+        expect(doc.at_xpath("//*[name()='ex:child']")).not_to be_nil
+        expect(doc.xpath("//*[name()='ex:grandchild']")).to be_empty
+        expect(doc.at_xpath("//*[local-name()='grandchild']")).not_to be_nil
+      end
+    end
+
+    context "with Serializable child but no form override" do
+      # Sanity: when no form: :qualified is set on the rule, the W3C
+      # element_form_default :unqualified override should still kick in and
+      # the nested Serializable should serialize unprefixed.
+      let(:child_class) do
+        ns = namespace_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :label, :string
+
+          xml do
+            element "child"
+            namespace ns
+            map_element "label", to: :label
+          end
+        end
+      end
+
+      let(:model_class) do
+        ns = namespace_class
+        child = child_class
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :child, child
+
+          xml do
+            element "item"
+            namespace ns
+            map_element "child", to: :child
+          end
+        end
+      end
+
+      it "honors element_form_default :unqualified by leaving the child unprefixed" do
+        instance = model_class.new(child: child_class.new(label: "x"))
+        doc = Nokogiri::XML(instance.to_xml)
+        expect(doc.xpath("//*[name()='ex:child']")).to be_empty
+        expect(doc.at_xpath("//*[local-name()='child']")).not_to be_nil
+      end
+    end
   end
 
   describe "form option on map_attribute" do
@@ -222,7 +451,7 @@ RSpec.describe "Enhanced XML Mapping Features" do
         instance = model_class.new(id: "ABC123")
         xml = instance.to_xml
         # Form affects qualification but implementation varies by adapter
-        expect(xml).to match(/id="ABC123"/)
+        expect(xml).to include('id="ABC123"')
       end
     end
 

data/spec/lutaml/xml/mapping_spec.rb

@@ -86,16 +86,16 @@ module XmlMappingSpec
   end
 
   class Address < Lutaml::Model::Serializable
-    attribute :street, ::Lutaml::Model::Type::String, raw: true
-    attribute :city, :string, raw: true
+    attribute :street, ::Lutaml::Model::Type::String
+    attribute :city, :string
     attribute :text, :string
     attribute :address, Address
 
     xml do
       element "address"
 
-      map_element "street", to: :street
-      map_element "city", to: :city
+      map_element "street", to: :street, raw: :content
+      map_element "city", to: :city, raw: :content
       map_element "text", to: :text
     end
   end