lutaml-model 0.8.31 → 0.8.32

data/spec/lutaml/model/collection_register_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+require_relative "../../../lib/lutaml/model"
+
+module CollectionRegisterSpec
+  # Inherits Collection#initialize, so it declares the register keyword.
+  class Standard < Lutaml::Model::Collection
+    instances :items, :string
+  end
+
+  # Overrides #initialize with the positional signature that predates the
+  # register. Passing the keyword to this raises ArgumentError.
+  class Positional < Lutaml::Model::Collection
+    instances :items, :string
+
+    def initialize(items = [])
+      super
+    end
+  end
+
+  # Accepts and forwards arbitrary keywords, so the register still arrives.
+  class Forwarding < Lutaml::Model::Collection
+    instances :items, :string
+
+    def initialize(items = [], **)
+      super
+    end
+  end
+
+  class UsesStandard < Lutaml::Model::Serializable
+    attribute :items, :string, collection: Standard
+    key_value { map "items", to: :items }
+  end
+
+  class UsesPositional < Lutaml::Model::Serializable
+    attribute :items, :string, collection: Positional
+    key_value { map "items", to: :items }
+  end
+
+  class UsesForwarding < Lutaml::Model::Serializable
+    attribute :items, :string, collection: Forwarding
+    key_value { map "items", to: :items }
+  end
+
+  class UsesPlainArray < Lutaml::Model::Serializable
+    attribute :items, :string, collection: true
+    key_value { map "items", to: :items }
+  end
+end
+
+RSpec.describe "collection construction and the register" do
+  let(:register) { Lutaml::Model::Register.new(:collection_register_spec) }
+
+  before { Lutaml::Model::GlobalRegister.register(register) }
+
+  describe "a custom collection whose constructor takes the register" do
+    it "receives the register used for the parse" do
+      obj = CollectionRegisterSpec::UsesStandard.from_json(
+        '{"items":["x","y"]}',
+        register: :collection_register_spec,
+      )
+
+      expect(obj.items.lutaml_register).to eq(:collection_register_spec)
+    end
+
+    it "receives it through a forwarding constructor too" do
+      obj = CollectionRegisterSpec::UsesForwarding.from_json(
+        '{"items":["x","y"]}',
+        register: :collection_register_spec,
+      )
+
+      expect(obj.items.lutaml_register).to eq(:collection_register_spec)
+    end
+  end
+
+  describe "a custom collection with a positional-only constructor" do
+    it "parses without raising ArgumentError" do
+      obj = nil
+
+      expect do
+        obj = CollectionRegisterSpec::UsesPositional.from_json(
+          '{"items":["x","y"]}',
+        )
+      end.not_to raise_error
+
+      expect(obj.items.to_a).to eq(%w[x y])
+    end
+
+    it "accepts assignment without raising ArgumentError" do
+      obj = CollectionRegisterSpec::UsesPositional.new
+
+      expect { obj.items = %w[x y] }.not_to raise_error
+      expect(obj.items.to_a).to eq(%w[x y])
+    end
+
+    # There is no way to hand a register to a constructor that does not take
+    # one, so such a collection resolves against the default register.
+    it "falls back to the default register under a non-default parse" do
+      obj = CollectionRegisterSpec::UsesPositional.from_json(
+        '{"items":["x"]}',
+        register: :collection_register_spec,
+      )
+
+      expect(obj.items.lutaml_register)
+        .to eq(Lutaml::Model::Config.default_register)
+    end
+  end
+
+  describe "a plain collection: true attribute" do
+    it "still builds a bare Array when a register is in play" do
+      obj = CollectionRegisterSpec::UsesPlainArray.from_json(
+        '{"items":["x","y"]}',
+        register: :collection_register_spec,
+      )
+
+      expect(obj.items).to be_an(Array)
+      expect(obj.items).to eq(%w[x y])
+    end
+  end
+end

data/spec/lutaml/model/collection_single_value_coercion_spec.rb

@@ -0,0 +1,222 @@
+require "spec_helper"
+require_relative "../../../lib/lutaml/model"
+
+module CollectionSingleValueCoercion
+  class Item < Lutaml::Model::Serializable
+    attribute :name, :string
+
+    xml do
+      element "item"
+      map_element "name", to: :name
+    end
+  end
+
+  class Basket < Lutaml::Model::Serializable
+    attribute :items, Item, collection: true
+    attribute :labels, :string, collection: true
+    attribute :sizes, :string, collection: 1..2
+
+    xml do
+      element "basket"
+      map_element "item", to: :items
+      map_element "label", to: :labels
+      map_element "size", to: :sizes
+    end
+  end
+
+  class NameParts < Lutaml::Model::Collection
+    instances :parts, :string
+  end
+
+  class MetadataEntries < Lutaml::Model::Collection
+    instances :entries, :hash
+  end
+
+  class Person < Lutaml::Model::Serializable
+    attribute :name_parts, :string, collection: NameParts
+    attribute :metadata_entries, :hash, collection: MetadataEntries
+
+    xml do
+      element "person"
+      map_element "part", to: :name_parts
+    end
+  end
+
+  class Coded < Lutaml::Model::Serializable
+    attribute :codes, :string, collection: true, pattern: /\A[a-z]+\z/
+
+    xml do
+      element "coded"
+      map_element "code", to: :codes
+    end
+  end
+
+  # Pattern applied to an attribute backed by a custom Collection class. The
+  # value is a Collection instance (not a plain Array), so pattern validation
+  # must flatten it per element rather than treat it as a single non-string.
+  class CodedCustom < Lutaml::Model::Serializable
+    attribute :codes, :string, collection: NameParts, pattern: /\A[a-z]+\z/
+
+    xml do
+      element "coded_custom"
+      map_element "code", to: :codes
+    end
+  end
+end
+
+RSpec.describe "single value coercion on collection attributes" do
+  describe "setter assignment" do
+    it "wraps a single model instance into a one-element array" do
+      basket = CollectionSingleValueCoercion::Basket.new
+      basket.items = CollectionSingleValueCoercion::Item.new(name: "one")
+
+      expect(basket.items).to be_a(Array)
+      expect(basket.items.map(&:name)).to eq(["one"])
+    end
+
+    it "wraps a single primitive into a one-element array" do
+      basket = CollectionSingleValueCoercion::Basket.new
+      basket.labels = "fragile"
+
+      expect(basket.labels).to eq(["fragile"])
+    end
+
+    it "leaves nil untouched" do
+      basket = CollectionSingleValueCoercion::Basket.new
+      basket.labels = nil
+
+      expect(basket.labels).to be_nil
+    end
+
+    it "leaves array assignment unchanged" do
+      basket = CollectionSingleValueCoercion::Basket.new
+      basket.labels = %w[a b]
+
+      expect(basket.labels).to eq(%w[a b])
+    end
+  end
+
+  describe "constructor assignment" do
+    it "wraps a single value passed to the constructor" do
+      basket = CollectionSingleValueCoercion::Basket.new(labels: "solo")
+
+      expect(basket.labels).to eq(["solo"])
+    end
+
+    it "produces the same shape as parsing one element" do
+      parsed = CollectionSingleValueCoercion::Basket.from_xml(
+        "<basket><label>solo</label></basket>",
+      )
+      built = CollectionSingleValueCoercion::Basket.new(labels: "solo")
+
+      expect(built.labels).to eq(parsed.labels)
+    end
+  end
+
+  describe "bounded collections" do
+    it "wraps a single value and satisfies the range validation" do
+      basket = CollectionSingleValueCoercion::Basket.new(sizes: "small")
+
+      expect(basket.sizes).to eq(["small"])
+      expect { basket.validate! }.not_to raise_error
+    end
+  end
+
+  describe "custom collection classes" do
+    it "wraps a single value into the custom collection" do
+      person = CollectionSingleValueCoercion::Person.new
+      person.name_parts = "Ada"
+
+      expect(person.name_parts)
+        .to be_a(CollectionSingleValueCoercion::NameParts)
+      expect(person.name_parts.to_a.size).to eq(1)
+    end
+
+    it "routes a plain Array through the collection branch element-wise" do
+      person = CollectionSingleValueCoercion::Person.new
+      person.name_parts = %w[Ada Lovelace]
+
+      expect(person.name_parts)
+        .to be_a(CollectionSingleValueCoercion::NameParts)
+      expect(person.name_parts.to_a.size).to eq(2)
+    end
+
+    it "does not double-cast arrays for hash-valued custom collections" do
+      person = CollectionSingleValueCoercion::Person.new
+      person.metadata_entries = [{ "text" => "x" }]
+
+      expect(person.metadata_entries)
+        .to be_a(CollectionSingleValueCoercion::MetadataEntries)
+      expect(person.metadata_entries.to_a).to eq(["x"])
+    end
+
+    it "does not double-cast single values for hash-valued custom collections" do
+      person = CollectionSingleValueCoercion::Person.new
+      person.metadata_entries = { "text" => "x" }
+
+      expect(person.metadata_entries)
+        .to be_a(CollectionSingleValueCoercion::MetadataEntries)
+      expect(person.metadata_entries.to_a).to eq(["x"])
+    end
+
+    it "rebuilds a fresh collection instead of sharing the assigned one" do
+      shared = CollectionSingleValueCoercion::NameParts.new(%w[Ada])
+      a = CollectionSingleValueCoercion::Person.new
+      b = CollectionSingleValueCoercion::Person.new
+
+      a.name_parts = shared
+      b.name_parts = shared
+
+      expect(a.name_parts).not_to be(shared)
+      expect(a.name_parts).not_to be(b.name_parts)
+      expect(a.name_parts.to_a).to eq(%w[Ada])
+    end
+  end
+
+  describe "pattern validation on collection attributes" do
+    it "validates a coerced single value per element" do
+      coded = CollectionSingleValueCoercion::Coded.new(codes: "abc")
+
+      expect(coded.codes).to eq(["abc"])
+      expect { coded.validate! }.not_to raise_error
+    end
+
+    it "validates each element of an assigned array" do
+      coded = CollectionSingleValueCoercion::Coded.new(codes: %w[abc def])
+
+      expect { coded.validate! }.not_to raise_error
+    end
+
+    it "rejects an element that violates the pattern" do
+      coded = CollectionSingleValueCoercion::Coded.new(codes: %w[abc DEF])
+
+      expect { coded.validate! }
+        .to raise_error(Lutaml::Model::ValidationError, /DEF/)
+    end
+
+    it "validates each element of a custom Collection per element" do
+      coded = CollectionSingleValueCoercion::CodedCustom.new(codes: %w[abc def])
+
+      expect { coded.validate! }.not_to raise_error
+    end
+
+    it "rejects a bad element inside a custom Collection" do
+      coded = CollectionSingleValueCoercion::CodedCustom.new(codes: %w[abc DEF])
+
+      expect { coded.validate! }
+        .to raise_error(Lutaml::Model::ValidationError, /DEF/)
+    end
+  end
+
+  describe "serialization round-trip" do
+    it "serializes a coerced single value as a repeated element would" do
+      basket = CollectionSingleValueCoercion::Basket.new
+      basket.items = CollectionSingleValueCoercion::Item.new(name: "one")
+
+      round_tripped = CollectionSingleValueCoercion::Basket.from_xml(
+        basket.to_xml,
+      )
+      expect(round_tripped.items.map(&:name)).to eq(["one"])
+    end
+  end
+end

data/spec/lutaml/model/root_mappings_spec.rb

@@ -280,14 +280,17 @@ RSpec.describe "RootMapping" do
         }
       end
 
-      it "raises error" do
+      it "parses, then reports the missing `collection: true` on validate" do
+        obj = nil
         expect do
-          RootMappingSpec::CeramicCollectionWithoutCollectionTrue.public_send(
-            :"from_#{format}", input
-          )
-        end.to raise_error(
-          Lutaml::Model::CollectionTrueMissingError,
-          "May be `collection: true` is missing for `ceramics` in RootMappingSpec::CeramicCollectionWithoutCollectionTrue",
+          obj = RootMappingSpec::CeramicCollectionWithoutCollectionTrue
+            .public_send(:"from_#{format}", input)
+        end.not_to raise_error
+
+        expect(obj.validate).to include(
+          an_object_having_attributes(
+            message: "May be `collection: true` is missing for `ceramics` in RootMappingSpec::CeramicCollectionWithoutCollectionTrue",
+          ),
         )
       end
     end