lutaml-model 0.8.31 → 0.8.32

data/spec/lutaml/model/serializable_validation_spec.rb

@@ -88,4 +88,297 @@ RSpec.describe Lutaml::Model::Serializable do
       expect { valid_instance.validate! }.not_to raise_error
     end
   end
+
+  # Regression: valid_pattern! must short-circuit non-string values instead of
+  # feeding nil / UninitializedClass to Regexp#match? (which raises TypeError).
+  describe "pattern with absent or nil values" do
+    it "does not raise when an optional patterned string is omitted" do
+      instance = TestSerializable.new(name: "Alice", age: [30])
+
+      errors = nil
+      expect { errors = instance.validate }.not_to raise_error
+      expect(errors).to be_none do |e|
+        e.is_a?(Lutaml::Model::PatternNotMatchedError)
+      end
+    end
+
+    it "skips nil elements in a patterned collection" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :codes, :string, collection: true, pattern: /\A[A-Z]+\z/
+        key_value { map "codes", to: :codes }
+      end
+
+      expect(klass.new(codes: ["ABC", nil, "DEF"]).validate).to be_empty
+      expect(klass.new(codes: ["ABC", "bad"]).validate).not_to be_empty
+    end
+
+    # valid_collection! must return truthy on success so validate_value!'s &&
+    # chain still reaches pattern validation for a bounded-range collection.
+    it "still runs pattern validation after a valid bounded-range collection" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :codes, :string, collection: 1..2, pattern: /\A[A-Z]+\z/
+        key_value { map "codes", to: :codes }
+      end
+
+      expect(klass.new(codes: ["ABC"]).validate).to be_empty
+      expect(klass.new(codes: ["bad"]).validate)
+        .to include(an_instance_of(Lutaml::Model::PatternNotMatchedError))
+    end
+  end
+
+  # Regression: enum (values:) on a collection must validate each element,
+  # not compare the whole coerced collection against the allowed set.
+  describe "enum on collection attributes" do
+    let(:klass) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :tags, :string, collection: true, values: %w[a b c]
+        key_value { map "tags", to: :tags }
+      end
+    end
+
+    it "accepts a single valid value coerced into the collection" do
+      expect(klass.new(tags: ["a"]).validate).to be_empty
+    end
+
+    it "accepts multiple valid values" do
+      expect(klass.new(tags: %w[a b]).validate).to be_empty
+    end
+
+    it "rejects a collection containing a disallowed element" do
+      expect(klass.new(tags: %w[a z]).validate)
+        .to include(an_instance_of(Lutaml::Model::InvalidValueError))
+    end
+  end
+
+  # Regression: a collection of nested models must recurse into every element
+  # so a grandchild's own validation errors surface on the parent.
+  describe "nested model collection validation" do
+    let(:child_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :status, :string, values: %w[ok fine]
+        key_value { map "status", to: :status }
+      end
+    end
+
+    let(:parent_class) do
+      child = child_class
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :items, child, collection: true
+        key_value { map "items", to: :items }
+      end
+    end
+
+    it "surfaces an invalid grandchild in a model collection" do
+      parent = parent_class.new(
+        items: [child_class.new(status: "ok"), child_class.new(status: "BAD")],
+      )
+
+      expect(parent.validate)
+        .to include(an_instance_of(Lutaml::Model::InvalidValueError))
+    end
+
+    it "returns no errors when every model element is valid" do
+      parent = parent_class.new(
+        items: [child_class.new(status: "ok"), child_class.new(status: "fine")],
+      )
+
+      expect(parent.validate).to be_empty
+    end
+  end
+
+  # Regression: a Collection is itself a model, so a nested one must be
+  # validated as one — iterating its elements alone skips collection-level
+  # rules such as validates_min_count.
+  describe "nested collection-level validation" do
+    let(:item_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+    end
+
+    let(:collection_class) do
+      item = item_class
+      Class.new(Lutaml::Model::Collection) do
+        instances :items, item
+        validates_min_count 2
+      end
+    end
+
+    let(:holder_class) do
+      collection = collection_class
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :items, collection
+      end
+    end
+
+    it "surfaces a nested collection's collection-level rule violation" do
+      holder = holder_class.new(
+        items: collection_class.new([item_class.new(name: "a")]),
+      )
+
+      expect(holder.validate)
+        .to include(an_instance_of(Lutaml::Model::ValidationFailedError))
+    end
+
+    it "returns no errors when the nested collection satisfies its rules" do
+      holder = holder_class.new(
+        items: collection_class.new(
+          [item_class.new(name: "a"), item_class.new(name: "b")],
+        ),
+      )
+
+      expect(holder.validate).to be_empty
+    end
+  end
+
+  # Regression: #validate is a public override point, so recursing into a child
+  # must not hand it arguments its own signature does not declare.
+  describe "nested model overriding #validate with zero arity" do
+    let(:child_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :status, :string
+
+        def validate
+          super << "child checked #{status}"
+        end
+      end
+    end
+
+    let(:parent_class) do
+      child = child_class
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :item, child
+        attribute :items, child, collection: true
+      end
+    end
+
+    it "surfaces errors from a zero-arity override on a single child" do
+      parent = parent_class.new(item: child_class.new(status: "one"))
+
+      expect(parent.validate).to include("child checked one")
+    end
+
+    it "surfaces errors from a zero-arity override on every element" do
+      parent = parent_class.new(
+        items: [child_class.new(status: "a"), child_class.new(status: "b")],
+      )
+
+      expect(parent.validate)
+        .to include("child checked a", "child checked b")
+    end
+  end
+
+  describe "models that reference themselves" do
+    let(:node_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        def self.name = "ValidationCycleSpec::Node"
+        attribute :name, :string, values: %w[ok]
+        attribute :parent, self
+        attribute :children, self, collection: true
+      end
+    end
+
+    it "validates a self-reference held in a collection" do
+      node = node_class.new(name: "ok")
+      node.children = [node]
+
+      expect { node.validate }.not_to raise_error
+      expect(node.validate).to be_empty
+    end
+
+    it "validates a self-reference held in a single attribute" do
+      node = node_class.new(name: "ok")
+      node.parent = node
+
+      expect { node.validate }.not_to raise_error
+      expect(node.validate).to be_empty
+    end
+
+    it "reports a cycled model's own errors exactly once" do
+      node = node_class.new(name: "bad")
+      node.children = [node]
+
+      expect(node.validate).to contain_exactly(
+        an_instance_of(Lutaml::Model::InvalidValueError),
+      )
+    end
+
+    it "still validates the same child twice when it is not a cycle" do
+      child = node_class.new(name: "bad")
+      parent = node_class.new(name: "ok", children: [child, child])
+
+      expect(parent.validate.size).to eq(2)
+    end
+
+    it "raises from validate! on a cycled model with a real error" do
+      node = node_class.new(name: "bad")
+      node.children = [node]
+
+      expect { node.validate! }.to raise_error(Lutaml::Model::ValidationError)
+    end
+
+    # The guard tracks visited models in thread-local state, so it has to clean
+    # up on the way out even when validate! raises.
+    it "leaves no thread-local state behind when validate! raises" do
+      node = node_class.new(name: "bad")
+      node.children = [node]
+
+      begin
+        node.validate!
+      rescue Lutaml::Model::ValidationError
+        nil
+      end
+
+      expect(Thread.current[Lutaml::Model::Validation::VALIDATING_KEY])
+        .to be_nil
+    end
+
+    # A downstream #validate override runs above the guard, so the cycle has
+    # to be cut before the override is entered, not inside it.
+    it "runs a downstream validate override once on a cycle" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        def self.name = "ValidationCycleSpec::Overrider"
+        attribute :children, self, collection: true
+
+        def validate
+          super << "override ran"
+        end
+      end
+      node = klass.new
+      node.children = [node]
+
+      expect(node.validate.count { |e| e == "override ran" }).to eq(1)
+    end
+
+    it "keeps the guard isolated between threads" do
+      node = node_class.new(name: "ok")
+      node.children = [node]
+
+      results = Array.new(4) { Thread.new { node.validate } }.map(&:value)
+
+      expect(results).to all(be_empty)
+    end
+  end
+
+  describe "collections that reference themselves" do
+    let(:collection_class) do
+      Class.new(Lutaml::Model::Collection) do
+        def self.name = "ValidationCycleSpec::Items"
+        instances :items, TestSerializable
+
+        validate_collection do |collection, errors, _ctx|
+          errors.add(:collection, "ran #{collection.count}")
+        end
+      end
+    end
+
+    # The rules used to run once inside the guarded pipeline and again from the
+    # outer call, because #validate was overridden above the guard.
+    it "runs its collection-level rules exactly once" do
+      collection = collection_class.new([])
+
+      ran = collection.validate.select { |e| e.to_s.include?("ran ") }
+      expect(ran.size).to eq(1)
+    end
+  end
 end

data/spec/lutaml/model/value_policy_spec.rb

@@ -67,9 +67,12 @@ RSpec.describe "ValuePolicy shaping of non-collection attributes" do
   end
 
   describe "built-in scalar types" do
-    it "keep the collection: true guidance error" do
-      expect { ValuePolicySpec::StringsDoc.from_yaml("v: [a]") }
-        .to raise_error(Lutaml::Model::CollectionTrueMissingError)
+    it "keep the collection: true guidance as a validate-time report" do
+      doc = nil
+      expect { doc = ValuePolicySpec::StringsDoc.from_yaml("v: [a]") }
+        .not_to raise_error
+      expect(doc.validate)
+        .to include(an_instance_of(Lutaml::Model::CollectionTrueMissingError))
     end
   end
 

data/spec/lutaml/model/xsd_form_default_patterns_spec.rb

@@ -66,7 +66,7 @@ RSpec.describe "XSD Form Default Patterns" do
         xsd = Lutaml::Model::Schema.to_xsd(model_class)
 
         # Per XSD spec, form attribute should NOT be emitted when it matches the default
-        expect(xsd).to include('<element name="premium" type="xs:string"/>')
+        expect(xsd).to include('<xs:element name="premium" type="xs:string"/>')
         expect(xsd).not_to include('form="unqualified"')
       end
 
@@ -125,7 +125,7 @@ RSpec.describe "XSD Form Default Patterns" do
 
         # Per XSD spec, form="unqualified" MUST be emitted when it differs from elementFormDefault
         expect(xsd).to include('form="unqualified"')
-        expect(xsd).to include('<element name="element" type="xs:string" form="unqualified"/>')
+        expect(xsd).to include('<xs:element name="element" type="xs:string" form="unqualified"/>')
       end
 
       it "serializes element without namespace prefix (as declared)" do
@@ -174,8 +174,8 @@ RSpec.describe "XSD Form Default Patterns" do
         xsd = Lutaml::Model::Schema.to_xsd(model_class)
 
         # Per XSD spec, form attribute should NOT be emitted when it matches elementFormDefault
-        expect(xsd).to include('<element name="name" type="xs:string"/>')
-        expect(xsd).to include('<element name="value" type="xs:string"/>')
+        expect(xsd).to include('<xs:element name="name" type="xs:string"/>')
+        expect(xsd).to include('<xs:element name="value" type="xs:string"/>')
         expect(xsd).not_to include('form="qualified"')
       end
 
@@ -364,7 +364,7 @@ RSpec.describe "XSD Form Default Patterns" do
         xsd = Lutaml::Model::Schema.to_xsd(model_class)
 
         # Per XSD spec, form attribute should NOT be emitted when it matches the default
-        expect(xsd).to include('<attribute name="id" type="xs:string"/>')
+        expect(xsd).to include('<xs:attribute name="id" type="xs:string"/>')
         expect(xsd).not_to include('form="unqualified"')
       end
 
@@ -414,7 +414,7 @@ RSpec.describe "XSD Form Default Patterns" do
 
         # Per XSD spec, form="unqualified" MUST be emitted when it differs from attributeFormDefault
         expect(xsd).to include('form="unqualified"')
-        expect(xsd).to include('<attribute name="id" type="xs:string" form="unqualified"/>')
+        expect(xsd).to include('<xs:attribute name="id" type="xs:string" form="unqualified"/>')
       end
 
       # NOTE: The following test documents a known issue where form: :unqualified
@@ -479,8 +479,8 @@ RSpec.describe "XSD Form Default Patterns" do
         xsd = Lutaml::Model::Schema.to_xsd(model_class)
 
         # Per XSD spec, form attribute should NOT be emitted when it matches attributeFormDefault
-        expect(xsd).to include('<attribute name="id" type="xs:string"/>')
-        expect(xsd).to include('<attribute name="type" type="xs:string"/>')
+        expect(xsd).to include('<xs:attribute name="id" type="xs:string"/>')
+        expect(xsd).to include('<xs:attribute name="type" type="xs:string"/>')
         expect(xsd).not_to include('form="qualified"')
       end
 
@@ -535,13 +535,13 @@ RSpec.describe "XSD Form Default Patterns" do
     it "emits form='unqualified' on element that differs from default" do
       xsd = Lutaml::Model::Schema.to_xsd(model_class)
 
-      expect(xsd).to include('<element name="element_content" type="xs:string" form="unqualified"/>')
+      expect(xsd).to include('<xs:element name="element_content" type="xs:string" form="unqualified"/>')
     end
 
     it "emits form='unqualified' on attribute that differs from default" do
       xsd = Lutaml::Model::Schema.to_xsd(model_class)
 
-      expect(xsd).to include('<attribute name="id" type="xs:string" form="unqualified"/>')
+      expect(xsd).to include('<xs:attribute name="id" type="xs:string" form="unqualified"/>')
     end
 
     it "serializes element without namespace prefix" do
@@ -596,7 +596,7 @@ RSpec.describe "XSD Form Default Patterns" do
         expect(xsd).to include('elementFormDefault="qualified"')
 
         # Elements should be declared WITHOUT form attribute (matches default)
-        expect(xsd).to include('<element name="premium" type="xs:string"/>')
+        expect(xsd).to include('<xs:element name="premium" type="xs:string"/>')
 
         # Instance should use prefixed elements when prefix: true is specified
         instance = model_class.new(premium: "100")
@@ -644,7 +644,7 @@ RSpec.describe "XSD Form Default Patterns" do
         expect(xsd).to include('attributeFormDefault="qualified"')
 
         # Attributes should be declared WITHOUT form attribute (matches default)
-        expect(xsd).to include('<attribute name="id" type="xs:string"/>')
+        expect(xsd).to include('<xs:attribute name="id" type="xs:string"/>')
 
         # Instance should use prefixed attributes
         instance = model_class.new(id: "abc")

data/spec/lutaml/model/xsd_patterns_spec.rb

@@ -20,11 +20,11 @@ RSpec.describe "XSD Three Pattern Architecture" do
       xsd = Lutaml::Model::Schema.to_xsd(klass)
 
       # Should generate inline complexType
-      expect(xsd).to include('<element name="product">')
-      expect(xsd).to include("<complexType>")
-      expect(xsd).not_to include("<complexType name=")
-      expect(xsd).to include('<element name="name" type="xs:string"/>')
-      expect(xsd).to include('<element name="value" type="xs:integer"/>')
+      expect(xsd).to include('<xs:element name="product">')
+      expect(xsd).to include("<xs:complexType>")
+      expect(xsd).not_to include("<xs:complexType name=")
+      expect(xsd).to include('<xs:element name="name" type="xs:string"/>')
+      expect(xsd).to include('<xs:element name="value" type="xs:integer"/>')
     end
 
     it "generates inline complexType for nested model without type_name" do
@@ -41,10 +41,10 @@ RSpec.describe "XSD Three Pattern Architecture" do
 
       xsd = Lutaml::Model::Schema.to_xsd(klass)
 
-      expect(xsd).to include('<element name="item">')
-      expect(xsd).to include("<complexType>")
-      expect(xsd).not_to include("<complexType name=")
-      expect(xsd).to include('<attribute name="id" type="xs:string"/>')
+      expect(xsd).to include('<xs:element name="item">')
+      expect(xsd).to include("<xs:complexType>")
+      expect(xsd).not_to include("<xs:complexType name=")
+      expect(xsd).to include('<xs:attribute name="id" type="xs:string"/>')
     end
   end
 
@@ -64,11 +64,11 @@ RSpec.describe "XSD Three Pattern Architecture" do
       xsd = Lutaml::Model::Schema.to_xsd(klass)
 
       # Should generate named complexType only (no element)
-      expect(xsd).to include('<complexType name="ProductType">')
-      expect(xsd).to include('<element name="name" type="xs:string"/>')
-      expect(xsd).to include('<element name="value" type="xs:integer"/>')
+      expect(xsd).to include('<xs:complexType name="ProductType">')
+      expect(xsd).to include('<xs:element name="name" type="xs:string"/>')
+      expect(xsd).to include('<xs:element name="value" type="xs:integer"/>')
       # Should NOT generate standalone element declaration
-      expect(xsd).not_to include('<element name="product"')
+      expect(xsd).not_to include('<xs:element name="product"')
     end
 
     it "type-only model can be referenced by other elements" do
@@ -99,8 +99,8 @@ RSpec.describe "XSD Three Pattern Architecture" do
       xsd = Lutaml::Model::Schema.to_xsd(person_klass)
 
       # Should reference AddressType
-      expect(xsd).to include('<element name="address" type="AddressType"/>')
-      expect(xsd).to include('<complexType name="AddressType">')
+      expect(xsd).to include('<xs:element name="address" type="AddressType"/>')
+      expect(xsd).to include('<xs:complexType name="AddressType">')
     end
   end
 
@@ -121,10 +121,10 @@ RSpec.describe "XSD Three Pattern Architecture" do
       xsd = Lutaml::Model::Schema.to_xsd(klass)
 
       # Should generate both element and named type
-      expect(xsd).to include('<element name="product" type="ProductType"/>')
-      expect(xsd).to include('<complexType name="ProductType">')
-      expect(xsd).to include('<element name="name" type="xs:string"/>')
-      expect(xsd).to include('<element name="value" type="xs:integer"/>')
+      expect(xsd).to include('<xs:element name="product" type="ProductType"/>')
+      expect(xsd).to include('<xs:complexType name="ProductType">')
+      expect(xsd).to include('<xs:element name="name" type="xs:string"/>')
+      expect(xsd).to include('<xs:element name="value" type="xs:integer"/>')
     end
 
     it "allows reuse of named type by other elements" do
@@ -143,9 +143,9 @@ RSpec.describe "XSD Three Pattern Architecture" do
       xsd = Lutaml::Model::Schema.to_xsd(klass)
 
       # Element references the named type
-      expect(xsd).to include('<element name="catalog" type="CatalogType"/>')
+      expect(xsd).to include('<xs:element name="catalog" type="CatalogType"/>')
       # Type definition exists separately
-      expect(xsd).to include('<complexType name="CatalogType">')
+      expect(xsd).to include('<xs:complexType name="CatalogType">')
     end
   end
 
@@ -192,8 +192,8 @@ RSpec.describe "XSD Three Pattern Architecture" do
 
       # Both should generate identical XSD
       expect(xsd1).to eq(xsd2)
-      expect(xsd1).to include('<element name="test" type="TestType"/>')
-      expect(xsd1).to include('<complexType name="TestType">')
+      expect(xsd1).to include('<xs:element name="test" type="TestType"/>')
+      expect(xsd1).to include('<xs:complexType name="TestType">')
     end
 
     it "xsd_type does NOT auto-set type-only (NO MAGIC)" do
@@ -232,8 +232,8 @@ RSpec.describe "XSD Three Pattern Architecture" do
       expect(mapping).not_to be_no_root
 
       xsd = Lutaml::Model::Schema.to_xsd(klass)
-      expect(xsd).to include('<element name="simple">')
-      expect(xsd).not_to include('<element name="simple" type=')
+      expect(xsd).to include('<xs:element name="simple">')
+      expect(xsd).not_to include('<xs:element name="simple" type=')
     end
 
     it "Pattern 2: type_name only -> named reusable" do
@@ -250,9 +250,9 @@ RSpec.describe "XSD Three Pattern Architecture" do
       expect(mapping.type_name_value).to eq("SimpleType")
 
       xsd = Lutaml::Model::Schema.to_xsd(klass)
-      expect(xsd).to include('<complexType name="SimpleType">')
+      expect(xsd).to include('<xs:complexType name="SimpleType">')
       # Should not have standalone element declaration (only child elements in sequence are OK)
-      expect(xsd).not_to include('<element name="SimpleType"')
+      expect(xsd).not_to include('<xs:element name="SimpleType"')
     end
 
     it "Pattern 3: both -> element with named type" do
@@ -270,8 +270,8 @@ RSpec.describe "XSD Three Pattern Architecture" do
       expect(mapping.type_name_value).to eq("SimpleType")
 
       xsd = Lutaml::Model::Schema.to_xsd(klass)
-      expect(xsd).to include('<element name="simple" type="SimpleType"/>')
-      expect(xsd).to include('<complexType name="SimpleType">')
+      expect(xsd).to include('<xs:element name="simple" type="SimpleType"/>')
+      expect(xsd).to include('<xs:complexType name="SimpleType">')
     end
   end
 end

data/spec/lutaml/model/xsd_type_validation_spec.rb

@@ -433,7 +433,7 @@ RSpec.describe "XSD Type Validation" do
         end
 
         xsd = described_class.generate(model)
-        expect(xsd).to match('<schema xmlns="http://www.w3.org/2001/XMLSchema">')
+        expect(xsd).to include('<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"')
         expect(xsd).to include('type="xs:string"')
         expect(xsd).to include('type="xs:integer"')
       end

data/spec/lutaml/turtle/transform_spec.rb

@@ -375,7 +375,7 @@ RSpec.describe Lutaml::Turtle::Transform do
       instance = UriRefModel.new(name: "test", related: ["skos:other"])
       turtle = instance.to_turtle
       restored = UriRefModel.from_turtle(turtle)
-      expect(restored.related).to eq("skos:other")
+      expect(restored.related).to eq(["skos:other"])
     end
 
     it "handles full URI values without prefix" do
@@ -390,7 +390,7 @@ RSpec.describe Lutaml::Turtle::Transform do
                                  related: ["http://example.org/foo"])
       turtle = instance.to_turtle
       restored = UriRefModel.from_turtle(turtle)
-      expect(restored.related).to eq("http://example.org/foo")
+      expect(restored.related).to eq(["http://example.org/foo"])
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.31
+  version: 0.8.32
 platform: ruby
 authors:
 - Ribose Inc.
@@ -780,6 +780,7 @@ files:
 - lib/lutaml/xml/namespace_scope_config.rb
 - lib/lutaml/xml/namespace_type_resolver.rb
 - lib/lutaml/xml/namespace_usage.rb
+- lib/lutaml/xml/nested_collection_attribute.rb
 - lib/lutaml/xml/nokogiri.rb
 - lib/lutaml/xml/nokogiri/element.rb
 - lib/lutaml/xml/oga.rb
@@ -1673,12 +1674,15 @@ files:
 - spec/lutaml/model/attribute_spec.rb
 - spec/lutaml/model/boot_manifest_spec.rb
 - spec/lutaml/model/cached_type_resolver_spec.rb
+- spec/lutaml/model/cardinality_strict_spec.rb
 - spec/lutaml/model/cdata_spec.rb
 - spec/lutaml/model/choice_restrict_spec.rb
 - spec/lutaml/model/choice_spec.rb
 - spec/lutaml/model/cli_spec.rb
 - spec/lutaml/model/collection_index_spec.rb
 - spec/lutaml/model/collection_mutation_spec.rb
+- spec/lutaml/model/collection_register_spec.rb
+- spec/lutaml/model/collection_single_value_coercion_spec.rb
 - spec/lutaml/model/collection_spec.rb
 - spec/lutaml/model/collection_state_nesting_spec.rb
 - spec/lutaml/model/collection_validation_spec.rb