lutaml-model 0.8.129 → 0.8.131

data/lib/lutaml/model/schema/xml_compiler/supported_data_types.rb

@@ -83,6 +83,16 @@ module Lutaml
           def skippable?(value)
             SKIPPABLE_NAMES.include?(value.to_s)
           end
+
+          # Lutaml primitive symbol for a skippable XSD type
+          # (`"int"` -> `:integer`, `"dateTime"` -> `:date_time`); nil
+          # when the name is not a skippable built-in.
+          def primitive_symbol(value)
+            info = TABLE[value.to_sym]
+            return nil unless info && info[:skippable]
+
+            Utils.snake_case(info[:class_name].split("::").last)
+          end
         end
       end
     end

data/lib/lutaml/model/serialize/attribute_definition.rb

@@ -120,6 +120,103 @@ module Lutaml
           RUBY
         end
 
+        # The walk-side seed (#1003): constructor-equivalent state in one
+        # compiled pass. Unlike the deserialization seed (sentinels, lazy
+        # collections — readers answer uninitialized), the programmatic
+        # constructor resolves defaults and leaves non-defaulted
+        # attributes nil with explicit using-default marks; the KV walk's
+        # absent-attribute rendering contract depends on exactly that.
+        def walk_state_defaults_name!(register_id)
+          @walk_state_defaults_names ||= {}
+          name = @walk_state_defaults_names[register_id]
+          return name if name
+
+          method_name = :"__init_walk_state_defaults_#{register_id}"
+          compile_walk_state_defaults!(method_name, register_id)
+          @walk_state_defaults_names[register_id] = method_name
+          method_name
+        end
+
+        def compile_walk_state_defaults!(method_name, register_id = nil)
+          attrs = attributes(register_id)
+          marks = {}
+          simple = []
+          complex = []
+          lazy = []
+          attrs.each do |name, attr|
+            next if attr.derived?
+
+            # Inline only the provably-simple shape: no default, no
+            # value set (enum attributes materialize through their
+            # writer), plain ivar-safe name. The constructor's end
+            # state for that shape is exactly `nil` + a false mark.
+            # Everything else — defaults, enums, delegated and exotic
+            # attributes — routes through the constructor's own
+            # per-attribute code, so its state is identical by
+            # construction.
+            marks[name] = false
+            plain_name = name.to_s.match?(PLAIN_NAME)
+            if plain_name && attr.lazy_collection_default?
+              # The implicit empty-collection default: the constructor
+              # ends at `[]` + a default mark, and the LAZY sentinel
+              # answers `[]` from the reader — so seed the sentinel and
+              # skip the per-instance lambda (#1010). The false mark is
+              # what the XML unmatched-rule contract reads: a seeded
+              # collection must not render as a mid-parse default.
+              lazy << name
+            elsif attr.default_kind == :none && attr.options[:values].nil? &&
+                plain_name
+              simple << name
+            else
+              complex << name
+            end
+          end
+
+          marks_line = if marks.empty?
+                         "@using_default = {}"
+                       else
+                         pairs = marks.map { |k, v| "#{k.inspect} => #{v}" }
+                         "@using_default = { #{pairs.join(', ')} }"
+                       end
+          simple_lines = simple.map { |n| "@#{n} = nil" }
+          lazy_lines = lazy.map do |n|
+            "@#{n} = Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION"
+          end
+          complex_lines = complex.map do |n|
+            "initialize_single_attribute({}, #{n.inspect}, " \
+              "self.class.attributes(@lutaml_register)[#{n.inspect}], " \
+              "Serialize::DEFAULT_VALUE_MAP)"
+          end
+
+          unless AttributeDefinition.source_compilation?
+            define_method(method_name) do
+              @using_default = marks
+              simple.each { |n| IVAR_SET.bind_call(self, :"@#{n}", nil) }
+              lazy.each do |n|
+                IVAR_SET.bind_call(
+                  self, :"@#{n}", Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION
+                )
+              end
+              complex.each do |n|
+                initialize_single_attribute(
+                  {}, n, self.class.attributes(@lutaml_register)[n],
+                  Serialize::DEFAULT_VALUE_MAP
+                )
+              end
+            end
+            return
+          end
+
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def #{method_name}
+              #{marks_line}
+              #{simple_lines.join("\n")}
+              #{lazy_lines.join("\n")}
+              #{complex_lines.join("\n")}
+            end
+          RUBY
+        end
+
         # Block-form raw-state reader (no String eval), defined on self.
         def define_raw_state_reader(name)
           ivar = :"@#{name}"
@@ -374,7 +471,7 @@ module Lutaml
 
           if !AttributeDefinition.source_compilation?
             define_block_attribute_setters(name, attr)
-          elsif attr.collection?
+          elsif attr.collection? && !attr.lazy_collection_default?
             # class_eval interpolates, e.g.:
             #   def items=(value)
             #     value_set_for(:items)
@@ -415,6 +512,25 @@ module Lutaml
                 record_mutation_collection(:#{name}, value)
               end
             RUBY
+          elsif attr.collection?
+            # Lazy-seeded default collections (#1010): a nil write is a
+            # real state here (initialize_empty reads nil after an
+            # explicit nil value), so it must land over the sentinel
+            # instead of preserving it.
+            class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+              def #{name}=(value)
+                value_set_for(:#{name})
+                value = __attribute_definition_#{name}.cast_value(value, lutaml_register)
+                @#{name} = value
+                record_mutation_collection(:#{name}, value)
+              end
+
+              def __assign_parsed_#{name}=(value)
+                value_set_for(:#{name})
+                @#{name} = value
+                record_mutation_collection(:#{name}, value)
+              end
+            RUBY
           else
             class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
               def #{name}=(value)
@@ -473,7 +589,7 @@ module Lutaml
           name = name.to_sym # the compiled form passes :name literals
           ivar = :"@#{name}"
           handle = :"__attribute_definition_#{name}"
-          if attr.collection?
+          if attr.collection? && !attr.lazy_collection_default?
             assign = lambda do |model, value|
               current = IVAR_GET.bind_call(model, ivar)
               unless current.equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION) &&
@@ -490,6 +606,21 @@ module Lutaml
               value_set_for(name)
               assign.call(self, value)
             end
+          elsif attr.collection?
+            # Lazy-seeded default collections (#1010): nil lands over the
+            # sentinel — see the source-compiled branch.
+            assign = lambda do |model, value|
+              IVAR_SET.bind_call(model, ivar, value)
+              SEND.bind_call(model, :record_mutation_collection, name, value)
+            end
+            define_method(:"#{name}=") do |value|
+              value_set_for(name)
+              assign.call(self, SEND.bind_call(self, handle).cast_value(value, lutaml_register))
+            end
+            define_method(:"__assign_parsed_#{name}=") do |value|
+              value_set_for(name)
+              assign.call(self, value)
+            end
           else
             define_method(:"#{name}=") do |value|
               value_set_for(name)

data/lib/lutaml/model/serialize/initialization.rb

@@ -363,6 +363,18 @@ module Lutaml
         #
         # @param register [Symbol, nil] The register context
         # @return [Object] The allocated instance
+        # Walk-side allocation (#1003): the KV walk's instantiation —
+        # constructor-equivalent state via the compiled walk seed
+        # (defaults resolved, non-defaulted attributes nil) without the
+        # per-attribute determine_value walk.
+        def allocate_for_walk(register = nil)
+          register_id = extract_register_id(register)
+          ensure_imports!(register_id) if finalized? && deferred_imports_pending?(register_id)
+          instance = allocate
+          instance.init_walk_state(register_id)
+          instance
+        end
+
         def allocate_for_deserialization(register = nil)
           register_id = extract_register_id(register)
           # Deferred imports (symbol-form import_model_attributes) must

data/lib/lutaml/model/serialize.rb

@@ -190,6 +190,18 @@ module Lutaml
         register_in_reference_store
       end
 
+      # Walk-side construction (#1003): constructor-equivalent state
+      # (defaults resolved, non-defaulted attributes nil, explicit
+      # using-default marks) seeded in one compiled pass, replacing the
+      # per-attribute determine_value walk on every parsed instance.
+      def init_walk_state(register)
+        register_id = self.class.extract_register_id(register)
+        @lutaml_register = register_id
+        public_send(self.class.walk_state_defaults_name!(register_id))
+        define_singleton_attribute_methods
+        register_in_reference_store
+      end
+
       def extract_register_id(attrs, options)
         register = attrs&.dig(:lutaml_register) || options&.dig(:register)
         self.class.extract_register_id(register)
@@ -378,19 +390,27 @@ module Lutaml
         self.class.attributes(lutaml_register).each do |name, attr|
           next if attr.derived?
 
-          value = determine_value(attrs, name, attr)
-          default = using_default?(name)
-          value = self.class.apply_value_map(value, vmap, attr)
-          # Performance: Only call ensure_utf8 for string values
-          value = self.class.ensure_utf8(value) if value.is_a?(::String)
-          # Interpolating the writer symbol allocated a String per
-          # attribute per instance; the per-register writer table is
-          # interned once per class.
-          public_send(self.class.instantiate_writers(lutaml_register)[name], value)
-          using_default_for(name) if default
+          initialize_single_attribute(attrs, name, attr, vmap)
         end
       end
 
+      # The constructor's per-attribute body, callable one attribute at
+      # a time — the compiled walk seed (#1003) routes every attribute
+      # it does not inline through this exact code, so its state is
+      # identical by construction.
+      def initialize_single_attribute(attrs, name, attr, vmap)
+        value = determine_value(attrs, name, attr)
+        default = using_default?(name)
+        value = self.class.apply_value_map(value, vmap, attr)
+        # Performance: Only call ensure_utf8 for string values
+        value = self.class.ensure_utf8(value) if value.is_a?(::String)
+        # Interpolating the writer symbol allocated a String per
+        # attribute per instance; the per-register writer table is
+        # interned once per class.
+        public_send(self.class.instantiate_writers(lutaml_register)[name], value)
+        using_default_for(name) if default
+      end
+
       def determine_value(attrs, name, attr)
         # One hash pass: a sentinel fetch distinguishes absent keys
         # from present-nil values, replacing two key probes plus the

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.129"
+    VERSION = "0.8.131"
   end
 end

data/lib/lutaml/toml/adapter/toml_rb_adapter.rb

@@ -19,13 +19,7 @@ module Lutaml
         def to_toml(*)
           require "toml-rb"
           # Handle KeyValueElement input (new symmetric architecture)
-          attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                      # Unwrap __root__ wrapper to get actual content
-                                      @attributes.to_hash["__root__"]
-                                    else
-                                      # Legacy Hash input (backward compatibility)
-                                      @attributes
-                                    end
+          attributes_to_serialize = @attributes
 
           TomlRB.dump(attributes_to_serialize)
         rescue LoadError

data/lib/lutaml/toml/adapter/tomlib_adapter.rb

@@ -34,13 +34,7 @@ module Lutaml
         def to_toml(*)
           require "tomlib"
           # Handle KeyValueElement input (new symmetric architecture)
-          attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                      # Unwrap __root__ wrapper to get actual content
-                                      @attributes.to_hash["__root__"]
-                                    else
-                                      # Legacy Hash input (backward compatibility)
-                                      @attributes
-                                    end
+          attributes_to_serialize = @attributes
 
           Tomlib.dump(attributes_to_serialize)
           # Tomlib::Generator.new(to_h).toml_str

data/lib/lutaml/xml/builder/base.rb

@@ -116,7 +116,9 @@ module Lutaml
 
         def add_xml_fragment(element, content)
           target = resolve_target(element)
-          parsed = @context.parse("<__root__>#{content}</__root__>")
+          # The wrapper tag only gives the parser a root; its name is
+          # discarded — only the parsed children are adopted.
+          parsed = @context.parse("<fragment>#{content}</fragment>")
           parsed.root&.children&.each { |child| target.add_child(child) }
         rescue Moxml::ParseError
           target.add_child(@doc.create_text(content.to_s))

data/lib/lutaml/xml/transformation/rule_compiler.rb

@@ -64,8 +64,8 @@ module Lutaml
           # This ensures root namespace is included in all_namespaces
           if mapping_dsl.namespace_class
             rules << ::Lutaml::Model::CompiledRule.new(
-              attribute_name: :__root_namespace__,
-              serialized_name: "__root__",
+              attribute_name: :root_namespace,
+              serialized_name: "root_namespace",
               namespace_class: mapping_dsl.namespace_class,
               mapping_type: :root_namespace,
             )

data/lib/lutaml/yaml/adapter/standard_adapter.rb

@@ -25,13 +25,7 @@ module Lutaml
 
         def to_yaml(options = {})
           # Handle KeyValueElement input (new symmetric architecture)
-          attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                      # Unwrap __root__ wrapper to get actual content
-                                      @attributes.to_hash["__root__"]
-                                    else
-                                      # Legacy Hash input (backward compatibility)
-                                      @attributes
-                                    end
+          attributes_to_serialize = @attributes
 
           YAML.dump(attributes_to_serialize, options)
         end

data/lib/lutaml/yaml/adapter/yeptris_adapter.rb

@@ -91,13 +91,7 @@ module Lutaml
         private_class_method :syntax_error
 
         def to_yaml(_options = {})
-          attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-                                      # Unwrap __root__ wrapper to get actual content
-                                      @attributes.to_hash["__root__"]
-                                    else
-                                      # Legacy Hash input (backward compatibility)
-                                      @attributes
-                                    end
+          attributes_to_serialize = @attributes
 
           # Generation must match the standard (Psych) adapter's output
           # byte-for-byte: document separator, quoting of digit-leading

data/lib/lutaml/yamlld/adapter.rb

@@ -12,12 +12,7 @@ module Lutaml
       end
 
       def to_yamlld(options = {})
-        attributes_to_serialize =
-          if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
-            @attributes.to_hash["__root__"]
-          else
-            @attributes
-          end
+        attributes_to_serialize = @attributes
         YAML.dump(attributes_to_serialize, options)
       end
     end

data/spec/lutaml/key_value/adapter/toml/teptris_adapter_spec.rb

@@ -54,12 +54,12 @@ RSpec.describe(TEPTRIS_AVAILABLE ? Lutaml::KeyValue::Adapter::Toml::TeptrisAdapt
         .to include("name", "[nested]", "a = [1, 2]")
     end
 
-    it "unwraps the __root__ KeyValueElement wrapper" do
-      element = Lutaml::KeyValue::DataModel::Element.new("__root__")
+    it "serializes Element children through their keyed hash shape" do
+      element = Lutaml::KeyValue::DataModel::Element.new("doc")
       name_child = Lutaml::KeyValue::DataModel::Element.new("name")
       name_child.value = "x"
       element.add_child(name_child)
-      expect(described_class.new(element).to_toml).to include("name")
+      expect(element.to_hash).to eq("doc" => { "name" => "x" })
     end
   end
 

data/spec/lutaml/key_value/group_instantiate_spec.rb

@@ -104,6 +104,14 @@ RSpec.describe "KV group-then-bulk hydration" do
           @built += 1
           super
         end
+
+        # The walk and group lanes construct through the compiled walk
+        # seed (#1003) rather than new; count that entry too so the
+        # wiring proof tracks the real construction path.
+        def allocate_for_walk(register = nil)
+          @built += 1
+          super
+        end
       end
     end
     holder = Class.new(Lutaml::Model::Serializable) do

data/spec/lutaml/key_value/transformation_spec.rb

@@ -69,14 +69,11 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVSimpleModel, mapping, :json, nil)
 
         result = transformation.transform(model)
-        hash = { "__root__" => result }
-
-        # Remove __root__ wrapper
-        expect(hash["__root__"]).to eq({
-                                         "name" => "John",
-                                         "age" => 30,
-                                         "active" => true,
-                                       })
+        expect(result).to eq({
+                               "name" => "John",
+                               "age" => 30,
+                               "active" => true,
+                             })
       end
 
       it "handles nil values based on render_nil" do
@@ -85,10 +82,8 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVSimpleModel, mapping, :json, nil)
 
         result = transformation.transform(model)
-        hash = { "__root__" => result }
-
         # nil values should be rendered by default
-        expect(hash["__root__"]["age"]).to be_nil
+        expect(result["age"]).to be_nil
       end
     end
 
@@ -101,16 +96,14 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVPerson, mapping, :json, nil)
 
         result = transformation.transform(person)
-        hash = { "__root__" => result }
-
-        expect(hash["__root__"]).to eq({
-                                         "name" => "John",
-                                         "address" => {
-                                           "street" => "123 Main St",
-                                           "city" => "NYC",
-                                           "zip" => "10001",
-                                         },
-                                       })
+        expect(result).to eq({
+                               "name" => "John",
+                               "address" => {
+                                 "street" => "123 Main St",
+                                 "city" => "NYC",
+                                 "zip" => "10001",
+                               },
+                             })
       end
 
       it "handles nil nested model" do
@@ -119,10 +112,8 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVPerson, mapping, :json, nil)
 
         result = transformation.transform(person)
-        hash = { "__root__" => result }
-
         # nil nested model should be in output (based on default render_nil)
-        expect(hash["__root__"]["address"]).to be_nil
+        expect(result["address"]).to be_nil
       end
     end
 
@@ -135,13 +126,11 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVTeam, mapping, :json, nil)
 
         result = transformation.transform(team)
-        hash = { "__root__" => result }
-
-        expect(hash["__root__"]).to eq({
-                                         "name" => "Dev Team",
-                                         "members" => ["Alice", "Bob",
-                                                       "Charlie"],
-                                       })
+        expect(result).to eq({
+                               "name" => "Dev Team",
+                               "members" => ["Alice", "Bob",
+                                             "Charlie"],
+                             })
       end
 
       it "handles empty collection" do
@@ -150,10 +139,8 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVTeam, mapping, :json, nil)
 
         result = transformation.transform(team)
-        hash = { "__root__" => result }
-
         # Empty collections are not rendered by default (render_empty defaults to false)
-        expect(hash["__root__"]["members"]).to be_nil
+        expect(result["members"]).to be_nil
       end
 
       it "handles nil collection" do
@@ -162,10 +149,8 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVTeam, mapping, :json, nil)
 
         result = transformation.transform(team)
-        hash = { "__root__" => result }
-
         # nil collection should be nil by default
-        expect(hash["__root__"]["members"]).to be_nil
+        expect(result["members"]).to be_nil
       end
     end
 
@@ -188,9 +173,7 @@ RSpec.describe Lutaml::KeyValue::Transformation do
                                              nil)
 
         result = transformation.transform(model)
-        hash = { "__root__" => result }
-
-        expect(hash["__root__"]["name"]).to eq("JOHN")
+        expect(result["name"]).to eq("JOHN")
       end
     end
 
@@ -211,10 +194,8 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVRenderModel, mapping, :json, nil)
 
         result = transformation.transform(model)
-        hash = { "__root__" => result }
-
         # optional should be omitted
-        expect(hash["__root__"].keys).not_to include("optional")
+        expect(result.keys).not_to include("optional")
       end
 
       it "omits default values when render_default: false" do
@@ -223,10 +204,8 @@ RSpec.describe Lutaml::KeyValue::Transformation do
         transformation = described_class.new(KVRenderModel, mapping, :json, nil)
 
         result = transformation.transform(model)
-        hash = { "__root__" => result }
-
         # defaulted should be omitted
-        expect(hash["__root__"].keys).not_to include("defaulted")
+        expect(result.keys).not_to include("defaulted")
       end
     end
   end
@@ -239,9 +218,6 @@ RSpec.describe Lutaml::KeyValue::Transformation do
 
       result = transformation.transform(model)
 
-      # Hash-direct emission: the __root__ Element tree (write-only in
-      # production, immediately flattened by every consumer) is gone;
-      # transform produces the output hash itself.
       expect(result).to be_a(Hash)
       expect(result).to eq("name" => "John", "age" => 30, "active" => true)
     end
@@ -257,7 +233,6 @@ RSpec.describe Lutaml::KeyValue::Transformation do
       expect(result).to be_a(Lutaml::KeyValue::DataModel::Element)
 
       # Presentation happens via to_hash, not during transformation
-      hash = { "__root__" => result }
       expect(hash).to be_a(Hash)
     end
   end
@@ -350,6 +325,31 @@ RSpec.describe Lutaml::KeyValue::Transformation do
       expect(model.to_hash).to eq("code" => "X")
     end
 
+    it "builds nested structures through chained Element writes" do
+      # glossarist's Citation#locality_to_yaml pattern: assign an empty
+      # hash child, then write into it through the hash-like reader —
+      # the reader must return the child's own value object.
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :type, :string
+        attribute :reference_from, :string
+
+        key_value do
+          map "locality", to: :type, with: { to: :locality_to_yaml }
+        end
+
+        def locality_to_yaml(model, doc)
+          doc["locality"] = {}
+          doc["locality"]["type"] = model.type
+          doc["locality"]["reference_from"] = model.reference_from
+        end
+      end
+
+      model = klass.new(type: "clause", reference_from: "§3")
+      expect(model.to_hash).to eq(
+        "locality" => { "type" => "clause", "reference_from" => "§3" },
+      )
+    end
+
     it "ignores a custom method's return value (mutation-only contract)" do
       # A method returning a hash without touching the doc serializes
       # as nothing — honoring returns merged child content at the

data/spec/lutaml/model/collection_spec.rb

@@ -416,6 +416,49 @@ RSpec.describe Lutaml::Model::Collection do
       expect(model.to_yaml).to eq(expected_yaml)
     end
 
+    # #1010: implicit-default collections are walk-seeded as the lazy
+    # sentinel instead of running the default lambda per instance. The
+    # sentinel answers [] on first read, and an explicit nil value must
+    # land over it — including through the deserialization fast path,
+    # whose writers otherwise preserve the sentinel.
+    it "reads nil when a parsed nil lands on the deserialization seed" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :items, :string, collection: true, initialize_empty: true
+        yaml { map "items", to: :items }
+      end
+
+      instance = klass.allocate_for_deserialization
+      instance.__assign_parsed_items = nil
+
+      expect(instance.items).to be_nil
+    end
+
+    it "materializes [] for untouched lazy-seeded collections" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :items, :string, collection: true, initialize_empty: true
+        yaml { map "items", to: :items }
+      end
+
+      parsed = klass.from_yaml("---\n{}\n")
+
+      expect(parsed.items).to eq([])
+      first = parsed.items
+      expect(parsed.items).to equal(first)
+    end
+
+    it "keeps an explicit default over the implicit empty collection" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :items, :integer,
+                  collection: true, initialize_empty: true,
+                  default: -> { [1, 2] }
+        yaml { map "items", to: :items }
+      end
+
+      parsed = klass.from_yaml("---\n{}\n")
+
+      expect(parsed.items).to eq([1, 2])
+    end
+
     it "raises StandardError for initialize_empty without collection" do
       expect do
         Class.new(Lutaml::Model::Serializable) do