lutaml-model 0.8.128 → 0.8.130

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d822754e3a7baeb6edb87dcfa7fb61c90c5da8b44920b2ad612905cb8ee9a278
-  data.tar.gz: ef8bcf9d531357fcd8d3fd07fc5053015c1b0e6202530866adf01f7e932123de
+  metadata.gz: 600c15c36628ae5051c4c447ebd9f6b8fe7e2b5b5c70dc894e2de663f2725a32
+  data.tar.gz: a5bcfd67b0416116fdfe806123ce7c679866fc292d19eb6eb1c6ea8849ac2e72
 SHA512:
-  metadata.gz: 9c4c5d63a666d0b8b99279de9dcf7fbee3031b694abba3729636249f701a4f67388507c13c778318f61d22ac1ce9a21940bf35960299e2a569fb024e302e3560
-  data.tar.gz: 7eb201762de275df248d27f7fc7c5e1019cd65e63822059b7075a69aae661d8a18f8123522797155665d8688d8147a6e06d46fdffde8fbc35e9f4347bd8424b9
+  metadata.gz: 46d83e87714efcd4d5c60f552eaf94aac748b5c121f458008a07eeece815e1121a00ad95623dc85bad3cab77204de675c0cd876ca0745fe9dfcb63655304ae67
+  data.tar.gz: be9904e6941df96b90c3feed829f399475a247ecc1900d86787d8dba224d1ef0a7ad8d68838ad13d5c4136df54d034dccb10bb72988424a95cf6541205243739

data/lib/lutaml/key_value/mapping_rule.rb

@@ -57,9 +57,8 @@ module Lutaml
       end
 
       def hash_mappings
-        return @root_mappings if @root_mappings
-
-        @child_mappings
+        @hash_mappings = @root_mappings || @child_mappings if @hash_mappings.nil?
+        @hash_mappings
       end
 
       def deep_dup
@@ -81,7 +80,8 @@ module Lutaml
       end
 
       def root_mapping?
-        name == "root_mapping"
+        @root_mapping = name == "root_mapping" if @root_mapping.nil?
+        @root_mapping
       end
 
       # The writer symbol for this rule's target, interned once per

data/lib/lutaml/key_value/transform.rb

@@ -28,7 +28,9 @@ module Lutaml
         end
 
         if model_class.include?(Lutaml::Model::Serialize)
-          instance = model_class.new(lutaml_register: child_register)
+          # #1003: constructor-equivalent state via the compiled walk
+          # seed — no per-attribute determine_value walk per instance.
+          instance = model_class.allocate_for_walk(child_register)
         else
           instance = model_class.new
           register_accessor_methods_for(instance, child_register)
@@ -430,7 +432,7 @@ child_hash, format, { mappings: type.child_rules })
             children << child
           end
         end
-        instance = model_class.new(lutaml_register: register)
+        instance = model_class.allocate_for_walk(register)
         setters.each { |name, value| instance.public_send(name, value) }
         absent&.each do |rule|
           process_mapping_rule(doc, instance, format, rule, options, nil)
@@ -477,7 +479,7 @@ options)
           to_method = rule.custom_methods[:to]
           # lutaml-model#550: custom methods may declare a third context
           # parameter to receive the options passed to `to_*`.
-          if instance.method(to_method).parameters.size >= 3
+          if Lutaml::Model::MappingRule.custom_method_arity(instance.class, to_method).to_i >= 3
             return instance.public_send(to_method, instance, hash,
                                         options[:context])
           end

data/lib/lutaml/key_value/transformation.rb

@@ -353,7 +353,7 @@ register = self.register)
           doc.value = {}
           # lutaml-model#550: custom methods may declare a third context
           # parameter to receive the options passed to `to_*`.
-          if model_instance.method(to_method).parameters.size >= 3
+          if Lutaml::Model::MappingRule.custom_method_arity(model_instance.class, to_method).to_i >= 3
             model_instance.public_send(to_method, model_instance,
                                        doc, options[:context])
           else

data/lib/lutaml/model/attribute.rb

@@ -624,6 +624,13 @@ instance_object = nil)
           value.frozen?
       end
 
+      # Static classification of this attribute's default form (:none,
+      # :static, :proc, :delegate) — the constructor's determine_value
+      # and the compiled walk-seed share it.
+      def default_kind
+        @default_kind ||= _default_kind
+      end
+
       def default_value(register, instance_object = nil)
         # The kind is fixed at definition; the common case (no default
         # at all) paid three option checks per absent attribute per
@@ -1368,7 +1375,9 @@ instance_object = nil)
       def set_default_for_collection
         validate_collection_range
         attr = self
-        @options[:default] ||= -> { attr.build_collection } if initialize_empty?
+        if initialize_empty?
+          @options[:default] ||= -> { attr.build_collection }
+        end
       end
 
       def validate_options!(options)

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -300,12 +300,31 @@ module Lutaml
         end
       end
 
+      # Arity of a custom (from:/to:) method, memoized per class+method:
+      # the reflection (method()/parameters) allocated per call and ran
+      # per value in the serialize/deserialize hot loops (42% of a
+      # custom-heavy to_json profile).
+      def self.custom_method_arity(klass, method_name)
+        per_klass = (@custom_method_arities ||= {}.compare_by_identity)
+        cache = (per_klass[klass] ||= {}.compare_by_identity)
+        cached = cache[method_name]
+        return cached if cached
+
+        begin
+          arity = klass.instance_method(method_name).parameters.size
+        rescue NameError
+          arity = nil
+        end
+        cache[method_name] = arity
+        arity
+      end
+
       def serialize(model, parent = nil, doc = nil, context = nil)
         if custom_methods[:to]
           to_method = custom_methods[:to]
           # lutaml-model#550: custom methods may declare a fourth
           # context parameter to receive the options passed to `to_*`.
-          if model.method(to_method).parameters.size >= 4
+          if self.class.custom_method_arity(model.class, to_method).to_i >= 4
             model.public_send(to_method, model, parent, doc, context)
           else
             model.public_send(to_method, model, parent, doc)
@@ -555,7 +574,7 @@ context = nil, pre_cast: false)
           target = mapper_class.new
           # lutaml-model#550: custom methods may declare a third context
           # parameter to receive the options passed to `from_*`.
-          if target.method(custom).parameters.size >= 3
+          if self.class.custom_method_arity(target.class, custom).to_i >= 3
             target.public_send(custom, model, value, context)
           else
             target.public_send(custom, model, value)

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

@@ -71,9 +71,10 @@ module Lutaml
         end
 
         def as_models(schema, options: {})
-          unless Config.xml_adapter.name.end_with?("NokogiriAdapter")
-            raise Error, XML_ADAPTER_NOT_SET_MESSAGE
-          end
+          # The schema builder resolves its own DOM builder from the
+          # configured adapter type (falling back to nokogiri); a stale
+          # adapter-class name check here rejected every caller after
+          # Config.xml_adapter became symbol-based (#251).
 
           parsed_schema = Lutaml::Xml::Schema::Xsd.parse(
             schema, location: options[:location]

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

@@ -120,6 +120,84 @@ 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 = []
+          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
+            if attr.default_kind == :none && attr.options[:values].nil? &&
+                name.to_s.match?(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" }
+          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) }
+              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")}
+              #{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}"

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.128"
+    VERSION = "0.8.130"
   end
 end

data/lib/lutaml/xml/schema/xsd/list.rb

@@ -18,6 +18,7 @@ module Lutaml
             map_attribute :id, to: :id
             map_attribute :itemType, to: :item_type
             map_element :annotation, to: :annotation
+            map_element :simpleType, to: :simple_type
           end
 
           Lutaml::Xml::Schema::Xsd.register_model(self, :list)

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/model/schema/xml_compiler_runtime_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema"
+require "tmpdir"
+
+# Runtime XSD-to-classes compilation (#251): Schema.from_xml compiles a
+# schema into generated Serializable classes, and with load_classes: the
+# classes are available in-process for direct parsing and serialization —
+# no generated files on disk.
+RSpec.describe "runtime XSD class loading" do
+  let(:xsd) do
+    <<~XSD
+      <?xml version="1.0" encoding="UTF-8"?>
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:complexType name="EntryType">
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="year" type="xs:integer"/>
+          </xs:sequence>
+          <xs:attribute name="id" type="xs:string" use="required"/>
+        </xs:complexType>
+        <xs:element name="entry" type="EntryType"/>
+      </xs:schema>
+    XSD
+  end
+
+  let(:instance_xml) do
+    <<~XML
+      <entry id="e1"><name>Alpha</name><year>2024</year></entry>
+    XML
+  end
+
+  it "compiles a schema, loads the classes, and round-trips an instance" do
+    Dir.mktmpdir do |dir|
+      Lutaml::Model::Schema.from_xml(
+        xsd, output_dir: File.join(dir, "runtime_pilot_models"),
+             load_classes: true
+      )
+
+      doc = RuntimePilotModels::EntryType.from_xml(instance_xml)
+
+      expect(doc.name).to eq("Alpha")
+      expect(doc.year).to eq(2024)
+      expect(doc.id).to eq("e1")
+
+      expect(doc.to_xml).to include("<name>Alpha</name>")
+      expect(doc.to_xml).to include("<year>2024</year>")
+      expect(doc.to_xml).to include('id="e1"')
+    end
+  end
+end

data/spec/lutaml/xml/schema/xsd/list_simple_type_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe "xs:list nested simpleType mapping" do
+  it "maps the inline simpleType of a list from the parsed XSD" do
+    xsd = <<~XSD
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:element name="r">
+          <xs:simpleType>
+            <xs:list>
+              <xs:simpleType>
+                <xs:restriction base="xs:string">
+                  <xs:enumeration value="a"/>
+                </xs:restriction>
+              </xs:simpleType>
+            </xs:list>
+          </xs:simpleType>
+        </xs:element>
+      </xs:schema>
+    XSD
+
+    schema = Lutaml::Xml::Schema::Xsd.parse(xsd)
+    list = schema.element.first.simple_type.list
+
+    expect(list.simple_type).to be_a(Lutaml::Xml::Schema::Xsd::SimpleType)
+    values = Array(list.simple_type.restriction.enumeration).map(&:value)
+    expect(values).to eq(["a"])
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.128
+  version: 0.8.130
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-24 00:00:00.000000000 Z
+date: 2026-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1837,6 +1837,7 @@ files:
 - spec/lutaml/model/schema/renderers/namespace_spec.rb
 - spec/lutaml/model/schema/renderers/restricted_type_spec.rb
 - spec/lutaml/model/schema/renderers/union_spec.rb
+- spec/lutaml/model/schema/xml_compiler_runtime_spec.rb
 - spec/lutaml/model/schema/xsd_schema_spec.rb
 - spec/lutaml/model/schema/yaml_schema_spec.rb
 - spec/lutaml/model/sequence_choice_compositor_spec.rb
@@ -2054,6 +2055,7 @@ files:
 - spec/lutaml/xml/schema/xsd/liquid_methods/element_spec.rb
 - spec/lutaml/xml/schema/xsd/liquid_methods/schema_spec.rb
 - spec/lutaml/xml/schema/xsd/liquid_methods/simple_content_spec.rb
+- spec/lutaml/xml/schema/xsd/list_simple_type_spec.rb
 - spec/lutaml/xml/schema/xsd/namespace_uri_remapping_spec.rb
 - spec/lutaml/xml/schema/xsd/schema_helper_methods_spec.rb
 - spec/lutaml/xml/schema/xsd/schema_mapping_spec.rb