lutaml-model 0.8.17 → 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/xml/opal_xml_spec.rb

@@ -2,9 +2,13 @@
 
 require "spec_helper"
 
-RSpec.describe "XML with REXML under Opal", if: RUBY_ENGINE == "opal" do
+# Adapter-agnostic XML round-trip scenarios, shared between Oga and
+# REXML smoke runs. Both adapters are pure Ruby and work under Opal;
+# this shared example is the contract that any future Opal-capable
+# adapter would also need to satisfy.
+RSpec.shared_examples "opal XML adapter round-trip" do |adapter_name|
   before do
-    Lutaml::Model::Config.xml_adapter_type = :rexml
+    Lutaml::Model::Config.xml_adapter_type = adapter_name
   end
 
   it "round-trips XML through parse and serialize" do
@@ -118,28 +122,26 @@ RSpec.describe "XML with REXML under Opal", if: RUBY_ENGINE == "opal" do
     expect(xml).to include("<title>Widget</title>")
     expect(xml).to include("<count>5</count>")
   end
+end
 
-  it "handles XmlOrderable on plain model classes" do
-    plain_model = Class.new do
-      attr_accessor :data
-    end
+# Pure-Ruby XML adapters that ship in the Opal bundle. Each nested
+# group runs the shared contract for its adapter; the top-level guard
+# gates the whole file under Opal.
+RSpec.describe "XML adapters under Opal", if: RUBY_ENGINE == "opal" do
+  describe "with Oga (default)" do
+    it_behaves_like "opal XML adapter round-trip", :oga
 
-    Class.new do
-      include Lutaml::Model::Serialize
-
-      const_set(:MODEL_CLASS, plain_model)
-      model plain_model
-      attribute :data, :string
-      xml do
-        element "data"
-        map_element "data", to: :data
-      end
+    it "uses Oga adapter by default under Opal" do
+      expect(Lutaml::Model::Config.xml_adapter_type).to eq(:oga)
     end
-
-    expect(plain_model.ancestors).to include(Lutaml::Xml::XmlOrderable)
   end
 
-  it "uses REXML adapter by default under Opal" do
-    expect(Lutaml::Model::Config.xml_adapter_type).to eq(:rexml)
+  describe "with REXML" do
+    it_behaves_like "opal XML adapter round-trip", :rexml
+
+    it "selects REXML when explicitly configured" do
+      Lutaml::Model::Config.xml_adapter_type = :rexml
+      expect(Lutaml::Model::Config.xml_adapter_type).to eq(:rexml)
+    end
   end
 end

data/spec/lutaml/xml/schema/compiler_spec.rb

@@ -41,8 +41,9 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
     it "keeps built-in W3C XML attribute types when processing xml.xsd" do
       described_class.as_models(xml_namespace_schema)
 
-      expect(described_class.attributes["id"].type)
-        .to eq("Lutaml::Xml::W3c::XmlIdType")
+      type_ref = described_class.builder.attributes["id"].type
+      expect(type_ref.kind).to eq(:w3c)
+      expect(type_ref.value).to eq("Lutaml::Xml::W3c::XmlIdType")
     end
   end
 
@@ -227,8 +228,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         let(:expected_classes) do
-          types = described_class::SimpleType::SUPPORTED_DATA_TYPES
-          classes = types.filter_map do |name, value|
+          classes = described_class::SupportedDataTypes::TABLE.filter_map do |name, value|
             name.to_s unless value[:skippable]
           end
           classes << "User"
@@ -751,4 +751,21 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
       end
     end
   end
+
+  describe "SupportedDataTypes.skippable?" do
+    # Attribute TypeRefs store the snake_case rendering, simple_content
+    # keeps the XSD spelling; skippable? must accept both for dateTime,
+    # the one skippable name that changes under snake_case.
+    it "matches both the XSD and snake_case spelling of skippable types" do
+      sdt = described_class::SupportedDataTypes
+      expect(sdt.skippable?("dateTime")).to be true
+      expect(sdt.skippable?("date_time")).to be true
+    end
+
+    it "still rejects non-skippable types in both spellings" do
+      sdt = described_class::SupportedDataTypes
+      expect(sdt.skippable?("nonNegativeInteger")).to be false
+      expect(sdt.skippable?("non_negative_integer")).to be false
+    end
+  end
 end