lutaml-model 0.8.41 → 0.8.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fc47a2bee1b20995c17426890ae3fdc3f9db24317a8cb0c83ea3e81f13372be
-  data.tar.gz: 72b52030485d681b901b077b75195a40d7779c0ec12df982e8bc7f49b3ef9dad
+  metadata.gz: 1cd747883eee7ea6a87aea0c708e6054f1f6cf9f7b06e295b32f1b7ba06a8a75
+  data.tar.gz: 639b21ad4dd77104b3bce40f0ba7bad925a5b608806e6e8979b50cb68f57b70e
 SHA512:
-  metadata.gz: dc281b89a9c032cff1f2a38de58b465dccc5385421d9daed7a8244adec62a282a79163b392224a2ead89d93281bbf1d6f5772f879f088a930332ae8821c7784e
-  data.tar.gz: 1d0c2b049cc9c45e7dfe0dd0a6ec6326c98011ab09c6a9f32eff39b36a67cfce1dd97f20341d301258acfc9c9eb282d43718d3a7ab0e0401ae29e6d1a936d724
+  metadata.gz: 05174a52193320261f496e92ac656b6ddc5a47167db5b98b3682c0397a4c9fb0f2a58f20e8be689d7f35486bea63dc2228d367574c3834587be6d5ba97306cd9
+  data.tar.gz: a6efef58f862390afe6fcf903ce3ff4d829d451079b7a1762990ed0e0bf1c5623c798c712a485d8e81cdc415189a37e9c5f7b1c02dd2d03ad6c17d96b5bac5a0

data/lib/lutaml/model/attribute.rb

@@ -172,30 +172,56 @@ module Lutaml
           end
         end
 
-        # Non-default register path: resolve directly without normalize_context
-        # when context_or_register is already a TypeContext or Symbol (common cases)
-        context = case context_or_register
-                  when Lutaml::Model::TypeContext
-                    context_or_register
-                  when Symbol
-                    GlobalContext.context(context_or_register) || GlobalContext.default_context
-                  when Lutaml::Model::Register
-                    GlobalContext.context(context_or_register.id) || GlobalContext.default_context
-                  else
-                    GlobalContext.default_context
-                  end
-
-        # Performance: Cache per TypeContext identity.
-        # When type substitution replaces a TypeContext, the object_id changes,
-        # so old cache entries are never hit again (safe invalidation).
-        cache_key = context.object_id
-        @type_cache ||= {}
-        cached = @type_cache[cache_key]
-        return cached if cached
-
-        resolved = resolver.resolve(unresolved_type, context)
-        @type_cache[cache_key] = resolved
-        resolved
+        # Register/Symbol path: the resolution is a static fact of
+        # (attribute, register id), but the old code walked
+        # GlobalContext.context — a singleton hop, a delegation, a to_sym
+        # normalization and a registry lookup — on every call (2.4 M calls,
+        # 3.9 M GlobalContext#context hits per ISO-13849 parse). Cache keyed
+        # on the register id itself; a context replaced under the same id
+        # bumps GlobalContext.context_generation and flushes the cache.
+        register_id = case context_or_register
+                      when Symbol
+                        context_or_register
+                      when Lutaml::Model::Register
+                        context_or_register.id
+                      end
+
+        if register_id
+          cache = (@type_cache_by_register ||= {})
+          generation = GlobalContext.context_generation
+          if @type_cache_generation != generation
+            cache.clear
+            @type_cache_generation = generation
+          end
+          cached = cache[register_id]
+          return cached if cached
+
+          context = GlobalContext.context(register_id)
+          # An unregistered id falls back to the (thread-local) default
+          # context — do not pin that answer in the shared cache.
+          return resolver.resolve(unresolved_type, context || GlobalContext.default_context) unless context
+
+          resolved = resolver.resolve(unresolved_type, context)
+          cache[register_id] = resolved
+          resolved
+        elsif context_or_register.is_a?(Lutaml::Model::TypeContext)
+          # Performance: Cache per TypeContext identity.
+          # When type substitution replaces a TypeContext, the object_id changes,
+          # so old cache entries are never hit again (safe invalidation).
+          cache_key = context_or_register.object_id
+          @type_cache ||= {}
+          cached = @type_cache[cache_key]
+          return cached if cached
+
+          resolved = resolver.resolve(unresolved_type, context_or_register)
+          @type_cache[cache_key] = resolved
+          resolved
+        else
+          @cached_type_default ||= begin
+            context = normalize_context(context_or_register)
+            resolver.resolve(unresolved_type, context)
+          end
+        end
       end
 
       # @api public
@@ -305,7 +331,10 @@ module Lutaml
       EMPTY_TRANSFORM_HASH = {}.freeze
 
       def transform
-        @options[:transform] || EMPTY_TRANSFORM_HASH
+        # Options are fixed after definition (value_policy memoizes the
+        # same way) — the per-call @options[:transform] Hash#[] was hit
+        # 2.9 M times on the ISO-13849 parse profile.
+        @transform ||= @options[:transform] || EMPTY_TRANSFORM_HASH
       end
 
       def method_name
@@ -438,7 +467,7 @@ module Lutaml
       def cast_element(value, register)
         # Resolve first: an undeclared type has to raise UnknownTypeError
         # even for a nil value (the 0.8.33 behavior).
-        type(register)
+        resolved_type = type(register)
 
         return value if Utils.uninitialized?(value)
 
@@ -448,7 +477,7 @@ module Lutaml
         # manufacture a typed INSTANCE from nothing: that is the
         # phantom #793 removed, suppressed by the post-check below.
         if value.nil?
-          result = cast_element_present(value, register)
+          result = cast_element_present(value, register, resolved_type)
           return result if result.nil?
           return nil if result.is_a?(Lutaml::Model::Type::Value) ||
             result.is_a?(Lutaml::Model::Serialize)
@@ -456,11 +485,11 @@ module Lutaml
           return result
         end
 
-        cast_element_present(value, register)
+        cast_element_present(value, register, resolved_type)
       end
 
-      def cast_element_present(value, register)
-        resolved_type = type(register)
+      def cast_element_present(value, register, resolved_type = nil)
+        resolved_type ||= type(register)
 
         return cast_union(value, nil, register) if union?
         return resolved_type.new(value) if value.is_a?(::Hash) && !hash_type?
@@ -474,8 +503,10 @@ module Lutaml
         # The castability verdict is a class-hierarchy fact, immutable
         # per resolved type — check once, not per value (TODO.max-perf/15).
         checked = (@castable_types ||= {}.compare_by_identity)
-        validate_attr_type!(resolved_type) unless checked[resolved_type]
-        checked[resolved_type] = true
+        unless checked[resolved_type]
+          validate_attr_type!(resolved_type)
+          checked[resolved_type] = true
+        end
 
         resolved_type.cast(value)
       end
@@ -518,6 +549,7 @@ instance_object = nil)
       def immutable_value?(value)
         value.nil? || value.is_a?(Numeric) || value.is_a?(String) ||
           value.is_a?(Symbol) || value == true || value == false ||
+          value.equal?(::Lutaml::Model::UninitializedClass.instance) ||
           value.frozen?
       end
 
@@ -925,6 +957,11 @@ instance_object = nil)
             Lutaml::Model::Type::Union.validate_members!(@options[:union_member_types])
           Lutaml::Model::Type::Union.validate_combo!(@options)
         end
+        # `restrict` merges new options into the SAME attribute object
+        # post-construction — the option-derived memos must reset here or
+        # collection?/transform keep answering from the pre-restrict state.
+        remove_instance_variable(:@collection_option) if defined?(@collection_option)
+        remove_instance_variable(:@transform) if defined?(@transform)
         @raw = !!@options[:raw]
         if @raw
           warn "[DEPRECATED] attribute :#{name}, :string, raw: true is deprecated. " \
@@ -1031,6 +1068,8 @@ instance_object = nil)
         @type_cache&.clear
         @cached_type_default = nil
         @default_type_context = nil
+        @type_cache_by_register&.clear
+        @type_cache_generation = nil
       end
 
       # Public validation contract: mappings check their targets at

data/lib/lutaml/model/collection_handler.rb

@@ -14,7 +14,9 @@ module Lutaml
       #
       # @return [Object, nil] The collection option value
       def collection
-        @options[:collection]
+        @collection_option = @options[:collection] unless defined?(@collection_option)
+
+        @collection_option
       end
 
       # Check if this attribute is a collection

data/lib/lutaml/model/global_context.rb

@@ -64,6 +64,18 @@ module Lutaml
         @default_context_id = :default
         @namespace_register_map = {} # namespace_uri => register_id
         @mutex = Mutex.new
+        @context_generation = 0
+      end
+
+      # Bumped whenever a named context is registered, replaced,
+      # unregistered, or the registry is reset. Callers that cache a
+      # resolution keyed on a context ID compare this generation to
+      # invalidate — a replaced context under the same ID must not keep
+      # answering from a stale cache.
+      #
+      # @return [Integer]
+      def context_generation
+        @context_generation
       end
 
       # Get the current default context.
@@ -123,6 +135,10 @@ module Lutaml
       # @return [void]
       def register_context(context)
         @registry.register(context)
+        # A replacement under an existing id must not keep answering from
+        # the resolver's [context.id, name]-keyed cache.
+        @resolver.clear_cache(context.id)
+        @context_generation += 1
       end
 
       # Create and register a new context.
@@ -133,12 +149,14 @@ module Lutaml
       # @param substitutions [Array<TypeSubstitution, Hash>] Type substitutions
       # @return [TypeContext] The created context
       def create_context(id:, registry: nil, fallback_to: [], substitutions: [])
-        @registry.create(
+        context = @registry.create(
           id: id,
           registry: registry,
           fallback_to: fallback_to,
           substitutions: substitutions,
         )
+        @context_generation += 1
+        context
       end
 
       # Unregister a context and clear its caches.
@@ -148,6 +166,7 @@ module Lutaml
       def unregister_context(id)
         @resolver.clear_cache(id)
         @registry.unregister(id)
+        @context_generation += 1
       end
 
       # Execute a block with a specific context as default.
@@ -185,6 +204,7 @@ module Lutaml
           end
           @namespace_register_map.clear
           @default_context_id = :default
+          @context_generation += 1
         end
       end
 
@@ -363,6 +383,10 @@ context_id = nil)
             instance.context(id)
           end
 
+          def context_generation
+            instance.context_generation
+          end
+
           def clear_xml_namespace_registry!
             instance.clear_xml_namespace_registry!
           end

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

@@ -122,6 +122,15 @@ module Lutaml
         @value_map[:from].freeze
         @value_map[:to].freeze
         @value_map.freeze
+
+        # The :from treatment flags are read on every rule application of
+        # every parse; they are static once @value_map is final. The three
+        # Hash#[] chains per value used to cost 1.4 M value_map calls per
+        # ISO-13849 parse.
+        from_map = @value_map[:from]
+        @treat_nil_flag = from_map[:nil] != :omitted
+        @treat_empty_flag = from_map[:empty] != :omitted
+        @treat_omitted_flag = from_map[:omitted] != :omitted
       end
 
       def default_value_map(options = {})
@@ -243,14 +252,20 @@ module Lutaml
       end
 
       def treat_nil?(options = {})
+        return @treat_nil_flag unless options[:nil] || options[:empty] || options[:omitted]
+
         value_map(:from, options)[:nil] != :omitted
       end
 
       def treat_empty?(options = {})
+        return @treat_empty_flag unless options[:nil] || options[:empty] || options[:omitted]
+
         value_map(:from, options)[:empty] != :omitted
       end
 
       def treat_omitted?(options = {})
+        return @treat_omitted_flag unless options[:nil] || options[:empty] || options[:omitted]
+
         value_map(:from, options)[:omitted] != :omitted
       end
 
@@ -402,6 +417,47 @@ context = nil)
       # Frozen empty array for the common case of no transformers
       EMPTY_TRANSFORMERS = [].freeze
 
+      # Verdict for handle_transform_method's dispatch, computed once per
+      # (rule, attribute) — both are static after definition, but rules may
+      # be frozen, so the memo lives at class level keyed on identity.
+      # :assign — no transformer runs on deserialize (fast path);
+      # :import — hash/proc transformers go through ImportTransformer.
+      TRANSFORM_DISPATCH = {}.compare_by_identity
+
+      def self.transform_dispatch(rule, attr)
+        per_attr = TRANSFORM_DISPATCH[rule]
+        if per_attr.nil?
+          per_attr = {}.compare_by_identity
+          TRANSFORM_DISPATCH[rule] = per_attr
+        end
+        verdict = per_attr[attr]
+        return verdict if verdict
+
+        rule_transform = rule.transform
+        # NB: `::Hash` — inside Lutaml::Model the bare constant `Hash` is
+        # the hash-format adapter class, so a plain is_a?(Hash) is always
+        # false here (the original dispatch shared that shadow and never
+        # took the hash-transform branch).
+        rule_has = rule_transform.is_a?(Class) ||
+          (rule_transform.is_a?(::Hash) && !rule_transform.empty?)
+        attr_transform = attr&.transform
+        attr_has = attr_transform &&
+          (attr_transform.is_a?(Class) ||
+           (attr_transform.is_a?(::Hash) && !attr_transform.empty?))
+
+        verdict = if !rule_has && !attr_has
+                    :assign
+                  elsif rule.get_transformers(attr).any? do |t|
+                    t.is_a?(Class) && t < Lutaml::Model::ValueTransformer
+                  end
+                    :assign
+                  else
+                    :import
+                  end
+        per_attr[attr] = verdict
+        verdict
+      end
+
       def get_transformers(attribute)
         # Fast path: most rules have no transforms at all
         rule_transform = transform
@@ -480,28 +536,16 @@ context = nil)
 
       def handle_transform_method(model, value, attributes, context = nil)
         attr = attributes[to]
-        # Fast path: no transforms at all (covers 95%+ of rules)
-        # transform defaults to {} which is truthy but semantically empty
-        rule_has_transform = transform.is_a?(Class) || (transform.is_a?(Hash) && !transform.empty?)
-        attr_has_transform = attr&.transform && (attr.transform.is_a?(Class) || (attr.transform.is_a?(Hash) && !attr.transform.empty?))
-        if !rule_has_transform && !attr_has_transform
-          assign_value(model, value)
-          return true
-        end
-
-        # If we have class-based transformers, they were already applied in transform_value
-        # Only call ImportTransformer for hash/proc-based transformers
-        transformers = get_transformers(attr)
-        has_class_transformer = transformers.any? { |t| t.is_a?(Class) && t < Lutaml::Model::ValueTransformer }
-
-        if has_class_transformer
-          # Class transformers already applied, just assign the value
-          assign_value(model, value)
-        else
-          # Hash/proc transformers need ImportTransformer
+        # The transform verdict (none / class-based already applied /
+        # hash-proc via ImportTransformer) is static per (rule, attr) —
+        # it was recomputed with is_a? chains on every rule application
+        # (16.8 M Kernel#is_a? per ISO-13849 parse across the walk).
+        if self.class.transform_dispatch(self, attr) == :import
           transformed = ImportTransformer.call(value, self, attr,
                                                context: context)
           assign_value(model, transformed)
+        else
+          assign_value(model, value)
         end
         true
       end

data/lib/lutaml/model/register.rb

@@ -87,12 +87,18 @@ module Lutaml
           (RESOLVE_CACHE[child_class] ||= {})[parent_register] =
             _resolve_for_child_uncached(child_class, parent_register)
         else
+          # Read-first: Concurrent::Map#compute_if_absent takes the mutex
+          # on EVERY call, hits included — 1.35 M synchronized blocks per
+          # ISO-13849 parse for answers that never change. The plain #[]
+          # read is lock-free; nil is a valid cached answer, hence key?.
           # Nested maps: class → register → result. Every hop keys on a
           # stable object (Class / Symbol), so the hot lookup allocates
           # nothing — the flat [object_id, register] array key cost one
           # Array per call, six per parsed element.
           per_class = RESOLVE_CACHE[child_class] # rubocop:todo Style/IdenticalConditionalBranches
-          per_class ||= RESOLVE_CACHE.compute_if_absent(child_class) do
+          return per_class[parent_register] if per_class&.key?(parent_register)
+
+          per_class = RESOLVE_CACHE.compute_if_absent(child_class) do
             Concurrent::Map.new
           end
           per_class.compute_if_absent(parent_register) do

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

@@ -122,12 +122,21 @@ module Lutaml
         # @param register [Symbol, nil] The register context
         # @return [Hash] The attributes hash
         def attributes(register = nil)
-          ensure_imports!(register) if finalized?
+          # Cache hit first: a filled entry can only exist after imports
+          # were ensured for that register (the fill path below runs
+          # ensure_imports! first), and mutations that invalidate the
+          # merge clear @merged_attributes_cache. The lookup was walked
+          # per rule application (751k per ISO-13849 parse).
           if @register_records&.any?
             register_id = extract_register_id(register)
-            (@merged_attributes_cache ||= {})[register_id] ||=
+            cached = (@merged_attributes_cache ||= {})[register_id]
+            return cached if cached
+
+            ensure_imports!(register) if finalized?
+            @merged_attributes_cache[register_id] ||=
               @attributes.merge(@register_records[register_id][:attributes])
           else
+            ensure_imports!(register) if finalized?
             @attributes
           end
         end

data/lib/lutaml/model/type/string.rb

@@ -5,7 +5,7 @@ module Lutaml
     module Type
       class String < Value
         # Performance-optimized cast with short-circuit for already-correct types
-        def self.cast(value, options = {})
+        def self.cast(value, options = EMPTY_OPTIONS)
           return nil if value.nil?
           return value if Utils.uninitialized?(value)
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.41"
+    VERSION = "0.8.42"
   end
 end

data/lib/lutaml/xml/model_transform.rb

@@ -315,6 +315,13 @@ module Lutaml
                     compiled_rule_records(instance.class, effective_register,
                                           grouped_plain_rules)
                   end
+        # Loop invariants: the entity-decode flag is a per-(class, register)
+        # fact and the attributes hash is memoized per register — both were
+        # re-asked per rule application (942k + 751k calls per ISO-13849
+        # parse).
+        decode_entities_flag = decode_html_entities_for(instance,
+                                                        effective_register)
+        deserialize_attributes = attributes
         mappings.each do |rule|
           record = records&.[](rule)
           rule_to = rule.to
@@ -376,6 +383,9 @@ module Lutaml
                                            default_namespace)
                     # Pre-match: no child element matches this rule.
                     # Skip expensive value_for_rule, handle defaults inline.
+                    # NOTE: do not "read the instance" here (to_value_for) —
+                    # the compiled getters materialize lazy collections on
+                    # first read, which tripled parse allocations when tried.
                     if instance.using_default?(rule_to) || rule.render_default
                       defaults_used << rule_to
                       attr&.default(effective_register) || rule.to_value_for(instance)
@@ -409,9 +419,7 @@ module Lutaml
           value = apply_value_map(value, from_map, attr)
           value = normalize_xml_value(value, rule, attr, new_opts,
                                       effective_register)
-          value = decode_html_entities_value(value, decode_html_entities_for(
-                                                      instance, effective_register
-                                                    ))
+          value = decode_html_entities_value(value, decode_entities_flag)
           value = rule.transform_value(attr, value, :from, :xml)
           # An over-count is normally left for `.validate` to report. A mapped
           # PORO has no `.validate`, so deferring there would discard the
@@ -420,7 +428,7 @@ module Lutaml
               !rule.content_mapping?
             attr.valid_collection!(value, context)
           end
-          rule.deserialize(instance, value, attributes, context,
+          rule.deserialize(instance, value, deserialize_attributes, context,
                            options[:context])
 
           instance.value_set_for(rule_to)
@@ -786,10 +794,27 @@ _effective_register)
       end
 
       def decode_html_entities_for(instance, register)
+        # Asked per rule application (942k per ISO-13849 parse) for a
+        # per-(class, register) fact; the transform instance itself is
+        # cached per (model class, register), so the memo lives here.
+        per_class = (@decode_html_entities_cache ||= {}.compare_by_identity)
+        per_register = (per_class[instance.class] ||= {})
+        return per_register[register] if per_register.key?(register)
+
         klass = instance.class
-        return false unless klass.is_a?(Class) && klass.include?(Lutaml::Model::Serialize)
+        per_register[register] = klass.is_a?(Class) &&
+          klass.include?(Lutaml::Model::Serialize) &&
+          (klass.mappings_for(:xml, register)&.decode_html_entities? || false)
+      end
+
+      # Serializable type class → its XML namespace class, asked per
+      # (rule × element) in value_for_rule / resolve_rule_names_with_type
+      # for a per-type static.
+      def type_namespace_class_of(type_class)
+        cache = (@type_ns_class_cache ||= {}.compare_by_identity)
+        return cache[type_class] if cache.key?(type_class)
 
-        klass.mappings_for(:xml, register)&.decode_html_entities?
+        cache[type_class] = type_class.mappings_for(:xml)&.namespace_class
       end
 
       def value_for_rule(session, rule, options, cached_attr = nil,
@@ -847,7 +872,7 @@ _effective_register)
         type_ns_all_uris = nil
         if attr_type_is_serializable
           type_ns_class = if attr_type_is_class
-                            attr_type.mappings_for(:xml)&.namespace_class
+                            type_namespace_class_of(attr_type)
                           else
                             attr.type_namespace_class(effective_register)
                           end
@@ -1292,7 +1317,7 @@ effective_register = lutaml_register)
         elsif precomputed_type.is_a?(Class) &&
             precomputed_type.include?(::Lutaml::Model::Serialize)
           # Use pre-computed type directly — avoids redundant attr.type() call
-          attr_type_ns_class = precomputed_type.mappings_for(:xml)&.namespace_class
+          attr_type_ns_class = type_namespace_class_of(precomputed_type)
           if attr_type_ns_class
             return ["#{attr_type_ns_class.uri}:#{rule.name}"]
           end
@@ -1309,7 +1334,7 @@ effective_register = lutaml_register)
           if attr_type_class
             attr_type_ns_class = if attr_type_class.is_a?(Class) &&
                 attr_type_class.include?(::Lutaml::Model::Serialize)
-                                   attr_type_class.mappings_for(:xml)&.namespace_class
+                                   type_namespace_class_of(attr_type_class)
                                  end
             if attr_type_ns_class
               return ["#{attr_type_ns_class.uri}:#{rule.name}"]

data/spec/lutaml/model/parse_dispatch_hoist_spec.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#811: the parse path re-resolved per (element × rule) what is
+# static per (attribute/rule, register). These guards pin the hoisting
+# contracts: register-keyed type caching with replacement invalidation,
+# the lock-free child-register resolution, per-rule treatment flags, and
+# the transform dispatch verdicts.
+RSpec.describe "parse-path dispatch hoisting" do
+  describe "Attribute#type register caching" do
+    let(:klass) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :value, :string
+      end
+    end
+
+    it "returns the same resolved class for a repeated register" do
+      attr = klass.attributes[:value]
+      expect(attr.type(:default)).to equal(attr.type(:default))
+    end
+
+    it "does not pin an unregistered register to the thread default" do
+      attr = klass.attributes[:value]
+      expect(attr.type(:nonexistent_register)).to eq(Lutaml::Model::Type::String)
+    end
+
+    it "re-resolves when a context is replaced under the same id" do
+      attr = klass.attributes[:value]
+
+      build_context = lambda do |string_type|
+        Lutaml::Model::TypeContext.new(
+          id: :hoist_test,
+          registry: Lutaml::Model::TypeRegistry.new.tap do |r|
+            r.register(:string, string_type)
+          end,
+        )
+      end
+
+      Lutaml::Model::GlobalContext.register_context(
+        build_context.call(Lutaml::Model::Type::String),
+      )
+      expect(attr.type(:hoist_test)).to equal(Lutaml::Model::Type::String)
+      expect(attr.type(:hoist_test)).to equal(Lutaml::Model::Type::String)
+
+      Lutaml::Model::GlobalContext.register_context(
+        build_context.call(Lutaml::Model::Type::Integer),
+      )
+      expect(attr.type(:hoist_test)).to equal(Lutaml::Model::Type::Integer)
+
+      Lutaml::Model::GlobalContext.unregister_context(:hoist_test)
+    end
+  end
+
+  describe "Register.resolve_for_child" do
+    it "caches a nil answer without recomputing" do
+      klass = Class.new(Lutaml::Model::Serializable)
+      expect(Lutaml::Model::Register.resolve_for_child(klass, nil)).to be_nil
+      expect(Lutaml::Model::Register.resolve_for_child(klass, nil)).to be_nil
+    end
+
+    it "resolves the child's own default register over the parent's" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        def self.lutaml_default_register
+          :child_default
+        end
+      end
+      expect(Lutaml::Model::Register.resolve_for_child(klass, :other)).to eq(:child_default)
+      expect(Lutaml::Model::Register.resolve_for_child(klass, nil)).to eq(:child_default)
+    end
+  end
+
+  describe "MappingRule treatment flags" do
+    def rule_with(treat_nil: :nil, treat_empty: :empty, treat_omitted: :nil)
+      Lutaml::Model::MappingRule.new(
+        "name", to: :name,
+                treat_nil: treat_nil, treat_empty: treat_empty,
+                treat_omitted: treat_omitted
+      )
+    end
+
+    it "computes the same answers as the value_map walk" do
+      rule = rule_with(treat_omitted: :omitted, treat_nil: :omitted)
+      expect(rule.treat_omitted?).to be(false)
+      expect(rule.treat_nil?).to be(false)
+      expect(rule.treat_empty?).to be(true)
+
+      expect(rule.treat_omitted?({})).to eq(rule.treat_omitted?)
+      expect(rule.treat_nil?({})).to eq(rule.treat_nil?)
+    end
+
+    it "honors per-call overrides over the precomputed flags" do
+      rule = rule_with
+      expect(rule.treat_omitted?).to be(true)
+      expect(rule.treat_omitted?({ omitted: :omitted })).to be(false)
+      expect(rule.treat_nil?({ nil: :omitted })).to be(false)
+      expect(rule.treat_empty?({ empty: :omitted })).to be(false)
+    end
+  end
+
+  describe "transform dispatch" do
+    let(:base) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :plain, :string
+        attribute :mapped, :string
+      end
+    end
+
+    it "assigns directly for a rule without transformers" do
+      rule = Lutaml::Model::MappingRule.new("mapped", to: :mapped)
+      expect(Lutaml::Model::MappingRule.transform_dispatch(
+               rule, base.attributes[:mapped]
+             )).to be(:assign)
+    end
+
+    it "routes hash transformers through ImportTransformer" do
+      rule = Lutaml::Model::MappingRule.new(
+        "mapped", to: :mapped,
+                  transform: { import: ->(v) { v.to_s.upcase } }
+      )
+      expect(Lutaml::Model::MappingRule.transform_dispatch(
+               rule, base.attributes[:mapped]
+             )).to be(:import)
+    end
+
+    it "applies an import transform through a real round trip" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :shout, :string
+
+        xml do
+          element "doc"
+          map_element "shout", to: :shout,
+                               transform: { import: ->(v) { v.to_s.upcase } }
+        end
+      end
+
+      expect(klass.from_xml("<doc><shout>soft</shout></doc>").shout).to eq("SOFT")
+    end
+  end
+
+  describe "uninitialized defaults are cached" do
+    let(:klass) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :nothing, :string
+      end
+    end
+
+    it "returns the same uninitialized sentinel without re-casting" do
+      attr = klass.attributes[:nothing]
+      expect(attr.default(:default)).to equal(attr.default(:default))
+      expect(attr.default(:default)).to equal(
+        Lutaml::Model::UninitializedClass.instance,
+      )
+    end
+  end
+
+  describe "html-entities decode flag" do
+    it "memoizes per class without changing the answer" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :body, :string
+
+        xml do
+          element "doc"
+          map_element "body", to: :body
+          html_entities
+        end
+      end
+
+      expect(klass.from_xml("<doc><body>a &amp; b</body></doc>").body).to eq("a & b")
+      expect(klass.from_xml("<doc><body>a &amp; b</body></doc>").body).to eq("a & b")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.41
+  version: 0.8.42
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1765,6 +1765,7 @@ files:
 - spec/lutaml/model/opal_smoke_spec.rb
 - spec/lutaml/model/optimization_spec.rb
 - spec/lutaml/model/ordered_content_spec.rb
+- spec/lutaml/model/parse_dispatch_hoist_spec.rb
 - spec/lutaml/model/parsed_model_mutation_spec.rb
 - spec/lutaml/model/phantom_value_spec.rb
 - spec/lutaml/model/polymorphic_spec.rb