lutaml-model 0.8.130 → 0.8.132

data/lib/lutaml/model/schema/xml_compiler/spec_builder/members.rb

@@ -110,8 +110,11 @@ module Lutaml
               end
 
               local = Utils.last_of_split(raw_type)
-              Definitions::TypeRef.new(kind: :symbol,
-                                       value: Utils.snake_case(local))
+              primitive = SupportedDataTypes.primitive_symbol(local)
+              Definitions::TypeRef.new(
+                kind: :symbol,
+                value: primitive || Utils.snake_case(local),
+              )
             end
 
             private
@@ -169,8 +172,10 @@ module Lutaml
                                                       element.simple_type)
               end
               if element.complex_type
-                return register_anonymous_complex_type("CT_#{element.name}",
-                                                       element.complex_type)
+                return register_anonymous_complex_type(
+                  "CT_#{element.name}", element.complex_type,
+                  root_name: element.name
+                )
               end
 
               "string"
@@ -184,8 +189,10 @@ module Lutaml
               end
 
               if item.respond_to?(:complex_type) && item.complex_type
-                register_anonymous_complex_type("CT_#{item.name}",
-                                                item.complex_type)
+                register_anonymous_complex_type(
+                  "CT_#{item.name}", item.complex_type,
+                  root_name: item.name
+                )
               end
             end
 
@@ -196,10 +203,10 @@ module Lutaml
               anon_name
             end
 
-            def register_anonymous_complex_type(anon_name, anon_node)
+            def register_anonymous_complex_type(anon_name, anon_node, root_name: nil)
               anon_node.name = anon_name
               @parent.complex_types[anon_name] =
-                @parent.build_complex_type(anon_node)
+                @parent.build_complex_type(anon_node, root_name: root_name)
               anon_name
             end
 

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

@@ -156,8 +156,8 @@ module Lutaml
             @simple_types_builder.build(simple_type)
           end
 
-          def build_complex_type(complex_type)
-            @complex_types_builder.build(complex_type)
+          def build_complex_type(complex_type, root_name: nil)
+            @complex_types_builder.build(complex_type, root_name: root_name)
           end
 
           private

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

@@ -142,6 +142,7 @@ module Lutaml
           marks = {}
           simple = []
           complex = []
+          lazy = []
           attrs.each do |name, attr|
             next if attr.derived?
 
@@ -154,8 +155,17 @@ module Lutaml
             # per-attribute code, so its state is identical by
             # construction.
             marks[name] = false
-            if attr.default_kind == :none && attr.options[:values].nil? &&
-                name.to_s.match?(PLAIN_NAME)
+            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
@@ -169,6 +179,9 @@ module Lutaml
                          "@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}], " \
@@ -179,6 +192,11 @@ module Lutaml
             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],
@@ -193,6 +211,7 @@ module Lutaml
             def #{method_name}
               #{marks_line}
               #{simple_lines.join("\n")}
+              #{lazy_lines.join("\n")}
               #{complex_lines.join("\n")}
             end
           RUBY
@@ -452,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)
@@ -493,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)
@@ -551,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) &&
@@ -568,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/transform.rb

@@ -3,12 +3,81 @@
 module Lutaml
   module Model
     class Transform
-      @transform_cache = {}
-
       # Maximum number of cached Transform instances before eviction.
       # Covers most OOXML/ISO schemas with ~1000+ classes and multiple registers.
       MAX_CACHE_SIZE = 2048
 
+      # The (lane, context, register) memo lives in a shared constant,
+      # not in class-level ivars: KeyValue::Transform subclasses this
+      # class, and inherited class methods run with the subclass as
+      # self — ivar state forked per subclass, and clear_cache! on the
+      # base class never reached the subclass's copy (stale compiled
+      # plans across register resets). The lane is part of the key:
+      # each transform class compiles format-specific rules, so a KV
+      # transform and the base one must never answer for each other.
+      class TransformCache
+        attr_reader :size
+
+        def initialize
+          @entries = {}
+          @size = 0
+        end
+
+        # Nested memo, not an array key: the hot path is one lookup per
+        # parsed node and the key array was that lookup's only
+        # allocation (60k arrays on a 6k-node corpus).
+        def fetch_or_store(lane, context, register)
+          by_context = @entries[lane]
+          by_register = by_context&.[](context)
+          return by_register[register] if by_register&.key?(register)
+
+          by_register = ((@entries[lane] ||= {})[context] ||= {})
+          transform = yield
+          by_register[register] = transform
+          @size += 1
+          transform
+        end
+
+        def evict_half_if_full
+          return unless @size >= MAX_CACHE_SIZE
+
+          drop = @size / 2
+          @entries.each do |lane, by_context|
+            by_context.each do |ctx, by_register|
+              break if drop <= 0
+
+              drop -= by_register.size
+              by_context.delete(ctx)
+            end
+            @entries.delete(lane) if by_context.empty?
+            break if drop <= 0
+          end
+          @size = @entries.sum { |_, by_context| by_context.sum { |_, br| br.size } }
+        end
+
+        def invalidate(context, register = nil)
+          @entries.each_value do |by_context|
+            if register
+              by_register = by_context[context]
+              next unless by_register&.delete(register)
+
+              @size -= 1
+              by_context.delete(context) if by_register.empty?
+            else
+              removed = by_context.delete(context)
+              @size -= removed.size if removed
+            end
+          end
+        end
+
+        def clear
+          @entries.clear
+          @size = 0
+        end
+      end
+
+      TRANSFORM_CACHE = TransformCache.new
+
       def self.data_to_model(context, data, format, options = {})
         register = options[:register] || Lutaml::Model::Config.default_register
         transform = cached_transform(context, register, options[:mappings])
@@ -28,13 +97,10 @@ module Lutaml
       def self.cached_transform(context, register, mappings = nil)
         return override_transform(context, register, mappings) if mappings
 
-        @transform_cache ||= {}
-        cache_key = [context, register]
-        entry = @transform_cache[cache_key]
-        return entry if entry
-
-        evict_if_needed if @transform_cache.size >= MAX_CACHE_SIZE
-        @transform_cache[cache_key] = new(context, register)
+        TRANSFORM_CACHE.evict_half_if_full
+        TRANSFORM_CACHE.fetch_or_store(self, context, register) do
+          new(context, register)
+        end
       end
 
       def self.override_transform(context, register, mappings)
@@ -54,30 +120,17 @@ module Lutaml
       private_class_method :evict_override_if_needed
 
       def self.clear_cache!
-        @transform_cache&.clear
+        TRANSFORM_CACHE.clear
         @override_transform_cache&.clear
       end
 
       def self.cache_size
-        @transform_cache&.size || 0
+        TRANSFORM_CACHE.size
       end
 
       def self.invalidate_for(context, register = nil)
-        return unless @transform_cache
-
-        if register
-          @transform_cache.delete([context, register])
-        else
-          @transform_cache.reject! { |(ctx, _reg)| ctx == context }
-        end
-      end
-
-      def self.evict_if_needed
-        # Evict oldest half of entries when cache is full
-        keys_to_remove = @transform_cache.keys.first(@transform_cache.size / 2)
-        keys_to_remove.each { |k| @transform_cache.delete(k) }
+        TRANSFORM_CACHE.invalidate(context, register)
       end
-      private_class_method :evict_if_needed
 
       attr_reader :context, :lutaml_register
 

data/lib/lutaml/model/type_context.rb

@@ -38,6 +38,8 @@ module Lutaml
     #   # Has :custom, falls back to default for built-in types
     #
     class TypeContext
+      EMPTY_SUBSTITUTIONS = [].freeze
+
       # @return [Symbol] The context identifier
       attr_reader :id
 
@@ -204,6 +206,13 @@ module Lutaml
       # @param from_type [Class, Symbol, String] The type to find substitutions for
       # @return [Array<TypeSubstitution>] Matching substitutions
       def substitution_for(from_type)
+        # The no-substitution context is the common case, and this
+        # lookup runs per nested model per serialized instance — the
+        # select's result array was the allocation (#KV-to profile
+        # 2026-10-26). The frozen shared array answers readers only;
+        # every consumer here selects/any?/eaches it.
+        return EMPTY_SUBSTITUTIONS if substitutions.empty?
+
         from_type_class = from_type.is_a?(Class) ? from_type : nil
 
         substitutions.select do |sub|

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.130"
+    VERSION = "0.8.132"
   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