lutaml-model 0.8.16 → 0.8.18

data/spec/fixtures/xml/validate_xml_with_product.xsd

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="product">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element name="sku">
+          <xs:simpleType>
+            <xs:restriction base="xs:string">
+              <xs:pattern value="[A-Z]{3}-[0-9]{4}"/>
+            </xs:restriction>
+          </xs:simpleType>
+        </xs:element>
+        <xs:element name="price" type="xs:decimal"/>
+        <xs:element name="released" type="xs:date"/>
+        <xs:element name="tag" type="xs:string" minOccurs="0" maxOccurs="3"/>
+        <xs:element name="note" type="xs:string" minOccurs="0"/>
+        <xs:element name="dimensions" minOccurs="0">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name="width" type="xs:integer"/>
+              <xs:element name="height" type="xs:integer"/>
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:sequence>
+      <xs:attribute name="id" type="xs:string" use="required"/>
+      <xs:attribute name="status">
+        <xs:simpleType>
+          <xs:restriction base="xs:string">
+            <xs:enumeration value="draft"/>
+            <xs:enumeration value="published"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:attribute>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>

data/spec/lutaml/integration/multi_format_spec.rb

@@ -3,6 +3,7 @@
 require "spec_helper"
 require "lutaml/turtle"
 require "lutaml/jsonld"
+require "lutaml/yamlld"
 
 RSpec.describe "Multi-format model" do
   before do
@@ -103,4 +104,26 @@ RSpec.describe "Multi-format model" do
       expect(turtle).to include("@prefix")
     end
   end
+
+  describe "YAML-LD format" do
+    it "serializes with @type and @id" do
+      yamlld = instance.to_yamlld
+      parsed = YAML.safe_load(yamlld)
+      expect(parsed["@type"]).to eq("skos:Concept")
+      expect(parsed["@id"]).to eq("http://example.org/concept/42")
+      expect(parsed["prefLabel"]).to eq("test")
+    end
+
+    it "round-trips" do
+      restored = MultiFormatModel.from_yamlld(instance.to_yamlld)
+      expect(restored.name).to eq("test")
+      expect(restored.code).to eq("42")
+    end
+
+    it "produces the same data model 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
 end

data/spec/lutaml/model/attribute_apply_value_map_spec.rb

@@ -0,0 +1,134 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
+  def attribute(type, **opts)
+    described_class.new("attr", type, **opts)
+  end
+
+  let(:uninit) { Lutaml::Model::UninitializedClass.instance }
+
+  describe "nil handling" do
+    it "maps nil through value_map[:nil] => :nil" do
+      expect(attribute(:string).apply_value_map(nil, { nil: :nil })).to be_nil
+    end
+
+    it "maps nil through value_map[:nil] => :empty to '' (scalar)" do
+      expect(attribute(:string).apply_value_map(nil, { nil: :empty })).to eq("")
+    end
+
+    it "maps nil through value_map[:nil] => :empty to [] (collection)" do
+      expect(
+        attribute(:string, collection: true).apply_value_map(nil, { nil: :empty }),
+      ).to eq([])
+    end
+
+    it "maps nil through value_map[:nil] => :empty to a custom collection class instance" do
+      # Regression: pre-consolidation Serialize::ValueMapping#empty_object used
+      # attr.build_collection (preserving custom collection class). The
+      # consolidated Attribute#apply_value_map must also use build_collection,
+      # not literal [], so attributes typed with a Lutaml::Model::Collection
+      # subclass don't silently downgrade to plain Array during model init.
+      member_class = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+      custom_collection_class = Class.new(Lutaml::Model::Collection) do
+        instances :items, member_class
+      end
+      attr = described_class.new("items", member_class, collection: custom_collection_class)
+      result = attr.apply_value_map(nil, { nil: :empty })
+      expect(result).to be_a(custom_collection_class)
+    end
+
+    it "maps nil through value_map[:nil] => :omitted to UninitializedClass" do
+      expect(attribute(:string).apply_value_map(nil, { nil: :omitted })).to eq(uninit)
+    end
+  end
+
+  describe "empty handling" do
+    it "maps '' through value_map[:empty] => :nil" do
+      expect(attribute(:string).apply_value_map("", { empty: :nil })).to be_nil
+    end
+
+    it "maps '' through value_map[:empty] => :empty preserving '' for scalar" do
+      expect(attribute(:string).apply_value_map("", { empty: :empty })).to eq("")
+    end
+
+    it "maps [] through value_map[:empty] => :empty preserving [] for collection" do
+      expect(
+        attribute(:string, collection: true).apply_value_map([], { empty: :empty }),
+      ).to eq([])
+    end
+
+    it "maps {} through value_map[:empty] => :empty preserving {} for Hash attribute" do
+      # Regression: must preserve the input type when source key matches the
+      # :empty mapping. Original value_for_option used `empty_value ||
+      # empty_object(attr)` which returned the truthy {} unchanged.
+      expect(attribute(:hash).apply_value_map({}, { empty: :empty })).to eq({})
+    end
+  end
+
+  describe "omitted handling" do
+    it "maps UninitializedClass through value_map[:omitted] => :nil" do
+      expect(attribute(:string).apply_value_map(uninit, { omitted: :nil })).to be_nil
+    end
+
+    it "maps UninitializedClass through value_map[:omitted] => :empty" do
+      expect(attribute(:string).apply_value_map(uninit, { omitted: :empty })).to eq("")
+    end
+
+    it "does NOT route UninitializedClass through the :empty branch" do
+      # Regression: Utils.empty?(UninitializedClass.instance) is false per
+      # utils.rb:132-137. Ensure dispatch order matches the originals: uninit
+      # values go to :omitted, not :empty.
+      expect(
+        attribute(:string).apply_value_map(uninit, { empty: :nil, omitted: :empty }),
+      ).to eq("")
+    end
+  end
+
+  describe "Boolean bare-form (Boolean attribute type required)" do
+    it "returns false directly for Boolean attribute, value_map[:empty] = false" do
+      expect(attribute(:boolean).apply_value_map("", { empty: false })).to be(false)
+    end
+
+    it "returns true directly for Boolean attribute, value_map[:omitted] = true" do
+      expect(attribute(:boolean).apply_value_map(uninit, { omitted: true })).to be(true)
+    end
+
+    it "does NOT apply bare-boolean form to a non-Boolean attribute (documented tightening)" do
+      # Plan §"Hidden behavior change" — bare-boolean form requires Boolean type.
+      # Falls through to the :empty option dispatch, which for an unknown option
+      # returns UninitializedClass.instance.
+      result = attribute(:string).apply_value_map("", { empty: false })
+      expect(result).to eq(uninit)
+    end
+  end
+
+  describe "Boolean nested-form (value_map[:from][:empty] / [:omitted])" do
+    it "returns false from value_map[:from][:empty] unconditionally for Boolean attribute" do
+      expect(attribute(:boolean).apply_value_map("", { from: { empty: false } })).to be(false)
+    end
+
+    it "returns true from value_map[:from][:omitted] unconditionally for Boolean attribute" do
+      expect(attribute(:boolean).apply_value_map(uninit, { from: { omitted: true } })).to be(true)
+    end
+
+    it "returns false from nested form even for non-Boolean attribute (no type gate)" do
+      expect(attribute(:string).apply_value_map("", { from: { empty: false } })).to be(false)
+    end
+  end
+
+  describe "pass-through" do
+    it "returns the value untouched when present and non-empty" do
+      expect(attribute(:string).apply_value_map("hello", {})).to eq("hello")
+    end
+
+    it "returns Boolean false untouched (real value, not 'empty')" do
+      expect(attribute(:boolean).apply_value_map(false, {})).to be(false)
+    end
+
+    it "returns Boolean true untouched" do
+      expect(attribute(:boolean).apply_value_map(true, {})).to be(true)
+    end
+  end
+end

data/spec/lutaml/model/attribute_spec.rb

@@ -191,7 +191,14 @@ RSpec.describe Lutaml::Model::Attribute do
 
     Lutaml::Model::Attribute::ALLOWED_OPTIONS.each do |option|
       it "return true if option is `#{option}`" do
-        expect(validate_options.call({ option => "value" })).to be(true)
+        if option == :xsd_type
+          expect do
+            result = validate_options.call({ option => "value" })
+            expect(result).to be(true)
+          end.to output.to_stderr
+        else
+          expect(validate_options.call({ option => "value" })).to be(true)
+        end
       end
     end
 
@@ -209,9 +216,19 @@ RSpec.describe Lutaml::Model::Attribute do
         age_attr.send(:validate_options!, { pattern: /[A-Za-z ]/ })
       end.to raise_error(
         StandardError,
-        "Invalid option `pattern` given for `age`, `pattern` is only allowed for :string type",
+        "Invalid option `pattern` given for `age`, `pattern` is only " \
+        "allowed for :string type or a union including a :string member",
       )
     end
+
+    it "allows pattern on a union that includes a :string member" do
+      attr = described_class.new(
+        "code", Lutaml::Model::Type::Union,
+        union_member_types: %i[integer string], pattern: /\A\d+\z/
+      )
+
+      expect(attr.pattern).to eq(/\A\d+\z/)
+    end
   end
 
   describe "#derived?" do
@@ -242,46 +259,193 @@ RSpec.describe Lutaml::Model::Attribute do
     end
   end
 
-  describe "#default via DefaultValueResolver" do
+  describe "#default" do
     let(:register) { Lutaml::Model::Config.default_register }
-
-    def create_resolver(attribute)
-      Lutaml::Model::Services::DefaultValueResolver.new(attribute, register,
-                                                        nil)
-    end
+    let(:instance) { nil }
 
     context "when default is not set" do
       let(:attribute) { described_class.new("name", :string) }
 
       it "returns uninitialized" do
-        expect(create_resolver(attribute).default).to be(Lutaml::Model::UninitializedClass.instance)
+        expect(attribute.default(register, instance)).to be(Lutaml::Model::UninitializedClass.instance)
       end
     end
 
     context "when default is set as a proc" do
       it "returns the value" do
         attribute = described_class.new("name", :string, default: -> { "John" })
-        expect(create_resolver(attribute).default).to eq("John")
+        expect(attribute.default(register, instance)).to eq("John")
       end
 
       it "returns the value casted to correct type" do
         file = Pathname.new("avatar.png")
         attribute = described_class.new("image", :string, default: -> { file })
 
-        expect(create_resolver(attribute).default).to eq("avatar.png")
+        expect(attribute.default(register, instance)).to eq("avatar.png")
       end
     end
 
     context "when default is set as value" do
       it "returns the value" do
         attribute = described_class.new("name", :string, default: "John Doe")
-        expect(create_resolver(attribute).default).to eq("John Doe")
+        expect(attribute.default(register, instance)).to eq("John Doe")
       end
 
       it "returns the value casted to correct type" do
         attribute = described_class.new("age", :integer, default: "24")
-        expect(create_resolver(attribute).default).to eq(24)
+        expect(attribute.default(register, instance)).to eq(24)
+      end
+
+      it "casts a String default to Integer for :integer attribute" do
+        attribute = described_class.new("count", :integer, default: "42")
+        expect(attribute.default(register, instance)).to eq(42)
+      end
+    end
+
+    context "with instance context" do
+      # Exercise instance_exec: the proc reads `name` from the instance,
+      # which is only resolvable when the proc is executed in the
+      # instance's context (`instance_object.instance_exec(&proc)`).
+      let(:model_class) do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :name, :string
+          attribute :greeting, :string, default: -> { "Hello, #{name}" }
+        end
+      end
+
+      it "executes and casts the proc in instance context" do
+        instance = model_class.new(name: "Alice")
+        attribute = model_class.attributes[:greeting]
+        expect(attribute.default(register, instance)).to eq("Hello, Alice")
+      end
+
+      it "bypasses the default cache when instance_object is given" do
+        attribute = model_class.attributes[:greeting]
+        first  = attribute.default(register, model_class.new(name: "Alice"))
+        second = attribute.default(register, model_class.new(name: "Bob"))
+        expect(first).to eq("Hello, Alice")
+        expect(second).to eq("Hello, Bob")
+      end
+    end
+  end
+
+  describe "#default_value" do
+    let(:register) { Lutaml::Model::Config.default_register }
+    let(:instance) { nil }
+
+    context "when default is a static value" do
+      it "returns the static value uncast" do
+        attribute = described_class.new("name", :string, default: "John")
+        expect(attribute.default_value(register, instance)).to eq("John")
+      end
+    end
+
+    context "when default is a proc without instance context" do
+      it "executes the proc" do
+        attribute = described_class.new("count", :integer, default: -> { 42 })
+        expect(attribute.default_value(register, instance)).to eq(42)
+      end
+    end
+
+    context "when default is a proc with instance context" do
+      let(:model_class) do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :name, :string
+          attribute :greeting, :string, default: -> { "Hello, #{name}" }
+        end
       end
+
+      it "executes the proc in the instance context (reads instance attribute)" do
+        instance = model_class.new(name: "Alice")
+        attribute = model_class.attributes[:greeting]
+        expect(attribute.default_value(register, instance)).to eq("Hello, Alice")
+      end
+    end
+  end
+
+  describe "#default_set?" do
+    let(:register) { Lutaml::Model::Config.default_register }
+    let(:instance) { nil }
+
+    it "returns false when default is not set" do
+      attribute = described_class.new("name", :string)
+      expect(attribute.default_set?(register, instance)).to be(false)
+    end
+
+    it "returns true when default is a static value" do
+      attribute = described_class.new("name", :string, default: "John")
+      expect(attribute.default_set?(register, instance)).to be(true)
+    end
+
+    it "returns true when default is a proc" do
+      attribute = described_class.new("name", :string, default: -> { "John" })
+      expect(attribute.default_set?(register, instance)).to be(true)
+    end
+  end
+
+  describe "#validate_value!" do
+    let(:register) { Lutaml::Model::Config.default_register }
+    let(:model) { Class.new(Lutaml::Model::Serializable).new }
+
+    context "when value is nil and the attribute has no default" do
+      it "treats nil-no-default as a permissible non-required value" do
+        attr = described_class.new("name", :string)
+        expect { attr.validate_value!(nil, register, instance_object: model) }
+          .not_to raise_error
+      end
+    end
+
+    context "when value is nil and the attribute has a default" do
+      it "uses the default value for validation" do
+        attr = described_class.new("name", :string, default: "John")
+        expect { attr.validate_value!(nil, register, instance_object: model) }
+          .not_to raise_error
+      end
+
+      it "executes a proc default in the instance context (instance_exec preserved)" do
+        # Regression: validate_value! must thread instance_object through
+        # default(register, instance_object) which calls instance_exec on
+        # the Proc. Verify by having the Proc read an instance attribute.
+        model_class = Class.new(Lutaml::Model::Serializable) do
+          attribute :prefix, :string, values: %w[Mr Ms Dr]
+          attribute :name, :string, values: %w[Alice Bob],
+                                    default: -> { "#{prefix}_default" }
+        end
+        instance = model_class.new(prefix: "Dr")
+        attr = model_class.attributes[:name]
+        expect { attr.validate_value!(nil, register, instance_object: instance) }
+          .to raise_error(Lutaml::Model::InvalidValueError) do |error|
+            # The error carries the value that was used for validation.
+            # If instance_exec ran, value is "Dr_default"; if not, error
+            # would never fire (proc would crash before reaching validation).
+            expect(error.message).to include("Dr_default")
+          end
+      end
+    end
+
+    context "when value is uninitialized" do
+      it "short-circuits without raising" do
+        uninit = Lutaml::Model::UninitializedClass.instance
+        attr = described_class.new("name", :string)
+        expect { attr.validate_value!(uninit, register, instance_object: model) }
+          .not_to raise_error
+      end
+    end
+  end
+
+  describe "Model initialization with proc defaults" do
+    # Regression: Serialize#determine_value previously called default_set?
+    # + default separately, executing the Proc twice for each omitted
+    # attribute. Verify single-execution by counting side effects.
+    it "executes a proc default exactly once when the attribute is omitted" do
+      counter = 0
+      model_class = Class.new(Lutaml::Model::Serializable) do
+        attribute :count, :integer, default: -> { counter += 1 }
+      end
+
+      instance = model_class.new
+      expect(instance.count).to eq(1)
+      expect(counter).to eq(1)
     end
   end
 

data/spec/lutaml/model/boot_manifest_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+# Guard: the generated Opal boot manifest must stay in sync with the autoloads
+# in lib/lutaml/**. Opal ignores `autoload`, so lutaml_model_boot.rb explicitly
+# requires every autoload target; a deleted/renamed file leaves a stale require
+# that only fails the Opal CI job (`rake spec:opal`) — MRI's autoload hides it.
+# Regenerating here and comparing catches that drift in the fast MRI suite.
+RSpec.describe "Opal boot manifest" do
+  let(:generator) do
+    File.expand_path("../../../lib/compat/opal/generate_boot.rb", __dir__)
+  end
+  let(:manifest) do
+    File.expand_path("../../../lib/compat/opal/lutaml_model_boot.rb", __dir__)
+  end
+
+  it "matches the generator output (regenerate: ruby lib/compat/opal/generate_boot.rb)" do
+    Dir.mktmpdir do |dir|
+      out = File.join(dir, "boot.rb")
+      ok = system({ "OPAL_BOOT_OUTPUT" => out }, RbConfig.ruby, generator,
+                  out: File::NULL, err: File::NULL)
+      expect(ok).to be(true), "generate_boot.rb failed to run"
+      expect(File.read(manifest)).to eq(File.read(out)),
+                                     "lib/compat/opal/lutaml_model_boot.rb is out of date — run " \
+                                     "`ruby lib/compat/opal/generate_boot.rb` after adding/removing autoloads"
+    end
+  end
+end